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
