def test_try_chain(): def function(exception): if exception is not None: raise exception() return 400 chain = Chain( try_chain(Chain(function), ).catch( ValueError, Chain(lambda: 501), ).catch( KeyError, Chain(lambda: 502), )) assert_that( chain(exception=None), is_(equal_to(400)), ) assert_that( chain(exception=ValueError), is_(equal_to(501)), ) assert_that( calling(chain).with_args(exception=ArithmeticError), raises(ArithmeticError), )
def test_try_complex_chain(): def function1(exception): if exception is ValueError: raise exception() return True def function2(exception): if exception is ArithmeticError: raise exception() return True chain = Chain( try_chain( function1, function2, ).catch(ValueError).then(lambda: 501, ).catch(ArithmeticError).then( lambda: 502, ).otherwise(Chain(lambda: 200), ), ) assert_that( chain(exception=ValueError), is_(equal_to(501)), ) assert_that( chain(exception=ArithmeticError), is_(equal_to(502)), ) assert_that( chain(exception=None), is_(equal_to(200)), )
def test_chain_in_a_chain(self): chain = Chain( extracts("arg")(lambda: 20), Chain(lambda arg: arg * 10, ), ) assert_that( chain(), is_(equal_to(200)), )
def test_for_each(): chain = Chain( for_each("item").in_("items").do(Chain(lambda item: item.upper()), ), Chain(lambda item_list: list(reversed(item_list))), ) assert_that( chain(items=["a", "b", "c"]), is_(equal_to(["C", "B", "A"])), )
def test_try_other(): def function(exception): return 400 chain = Chain( try_chain(Chain(function), ).otherwise(Chain(lambda: 200), ), ) assert_that( chain(exception=None), is_(equal_to(200)), )
def test_when(): chain = Chain( when("arg").then(Chain(lambda: 200), ).otherwise( Chain(lambda: 400), ), ) assert_that( chain(arg=True), is_(equal_to(200)), ) assert_that( chain(arg=False), is_(equal_to(400)), )
def test_assign_missing_property(): chain = Chain(assign("arg.missing").to("param"), ) assert_that( calling(chain).with_args(arg=dict(data=200)), raises(AttributeNotFound, "Failed to find attribute `missing` on `arg`"), )
def test_assign_attribute(): chain = Chain( assign("arg.__class__").to("param"), ) assert_that( chain(arg=dict()), is_(equal_to(dict)), )
def test_assign_constant(): chain = Chain( assign_constant("arg").to("param"), ) assert_that( chain(), is_(equal_to("arg")), )
def test_assign_property(): chain = Chain( assign("arg.data").to("param"), ) assert_that( chain(arg=dict(data=200)), is_(equal_to(200)), )
def test_assign_function_with_noargs(): chain = Chain( assign_function(lambda: dict()).to("param"), ) assert_that( chain(), is_(equal_to(dict())), )
def test_extractwith_property_simplified(): chain = Chain( extract("param", "arg.data"), ) assert_that( chain(arg=dict(data=200)), is_(equal_to(200)), )
def test_extractreturn_value(): chain = Chain( extract("param", "arg"), ) assert_that( chain(arg=200), is_(equal_to(200)), )
def test_assign_function_with_builtin(): chain = Chain( assign_function(dict).to("param"), ) assert_that( chain(), is_(equal_to(dict())), )
def test_empty_switch(): chain = Chain( switch("arg"), ) assert_that( chain(arg=None), is_(equal_to(None)), )
def case(self, key, *args, **kwargs): if not args and not kwargs: return CaseStatement(self, key) self._cases.append( (key, Chain.make(*args, **kwargs)), ) return self
def test_extractwith_attribute_simplified(): chain = Chain( extract("param", "arg.__class__"), ) assert_that( chain(arg=dict()), is_(equal_to(dict)), )
def test_assign_function_with_context_arg(): def func(context): return "value" chain = Chain(assign_function(func).to("param"), ) assert_that( chain(), is_(equal_to("value")), )
def test_extract(): chain = Chain( extract("param", "arg"), lambda param: param, ) assert_that( chain(arg=200), is_(equal_to(200)), )
def test_for_each_when(): chain = Chain( for_each("item").in_("items").do( lambda item: None if item % 2 else item, ).when_not_none(), ) assert_that( chain(items=[0, 1, 2, 3, 4, 5]), is_(equal_to([0, 2, 4])), )
def test_error_on_overwrite_parent_context(self): # the kwargs in `with_args` overshadows an existing key on the context chain = Chain( call(sum).with_args(input="another_word").as_("twelve"), ) assert_that( calling(chain).with_args(input="hello", another_word="world"), raises(ValueError), )
def test_chain_returns_value(self): chain = Chain( lambda: 100, lambda: 200, ) assert_that( chain(), is_(equal_to(200)), )
def test_chain_functions_can_use_decorators(self): chain = Chain( extracts("arg")(lambda: 20), lambda arg: arg * 10, ) assert_that( chain(), is_(equal_to(200)), )
def get_chain(self): return Chain( assign("delivery_event.orderId").to("order_id"), self.extract_order, assign("order.customerId").to("customer_id"), self.extract_latest_order_event, assign("latest_order_event.eventType").to("last_event_type"), self.assert_order_ready_for_fulfillment, self.set_order_fulfilled_event, )
def test_empty_when(): chain = Chain(when("arg"), ) assert_that( chain(arg=True), is_(equal_to(None)), ) assert_that( chain(arg=False), is_(equal_to(None)), )
def test_call_with_string_constant(self): def concatenate(word, suffix): return f"{word}{suffix}" chain = Chain( call(concatenate).with_args(suffix="er").as_("more_word"), ) assert_that( chain(word="high"), equal_to("higher"), )
def test_for_each_simplified(): chain = Chain( for_each("item").in_("items").do( lambda item: item.upper(), ).as_("lst"), lambda lst: list(reversed(lst)), ) assert_that( chain(items=["a", "b", "c"]), is_(equal_to(["C", "B", "A"])), )
def test_mix_parent_child_context(self): # `sum_base` will come from the parent context # `addend` will be defined using `call` def sum(sum_base, addend): return sum_base + addend chain = Chain(call(sum).with_args(addend="two").as_("twelve"), ) assert_that( chain(sum_base=10, two=2), equal_to(12), )
def test_switch(): chain = Chain( switch("arg").case( True, Chain(lambda: 200), ).case( False, Chain(lambda: 400), ).otherwise(Chain(lambda: 500), ), ) assert_that( chain(arg=True), is_(equal_to(200)), ) assert_that( chain(arg=False), is_(equal_to(400)), ) assert_that( chain(arg=None), is_(equal_to(500)), )
def test_call_with_constant(self): def sum(sum_base, addend): return sum_base + addend def noop(twelve): return twelve chain = Chain( call(sum).with_args(addend=2).as_("twelve"), noop, ) assert_that( chain(sum_base=10), equal_to(12), )
def otherwise(self, *args, **kwargs): self._otherwise = Chain.make(*args, **kwargs) return self
def then(self, *args, **kwargs): self._then = Chain.make(*args, **kwargs) return self
def do(self, *args, **kwargs): self.chain = Chain.make(*args, **kwargs) return self