def test_rescue_failure():
"""Ensures that rescue works for Failure container."""
def factory(inner_value) -> RCR[int, int, str]:
return RCR.from_failure(inner_value * 2)
assert RCR.from_success(5).rescue(
factory,
)(0) == RCR.from_success(5)(0)
assert RCR.from_failure(5).rescue(
factory,
)(0) == RCR.from_failure(10)(0)
def test_bind_regular_context():
"""Ensures that regular ``RequiresContext`` can be bound."""
def factory(inner_value: int) -> RequiresContext[int, float]:
return RequiresContext(lambda deps: inner_value / deps)
first: RCR[int, int, str] = RCR.from_success(1)
third: RCR[int, int, str] = RCR.from_failure('a')
assert first.bind_context(factory)(2) == Success(0.5)
assert RCR.from_success(2).bind_context(
factory,
)(1) == Success(2.0)
assert third.bind_context(factory)(1) == Failure('a')
def test_bind():
"""Ensures that bind works."""
def factory(inner_value: int) -> RCR[int, float, str]:
if inner_value > 0:
return RCR(lambda deps: Success(inner_value / deps))
return RCR.from_failure(str(inner_value))
input_value = 5
bound: RCR[int, int, str] = RCR.from_success(input_value)
assert bound.bind(factory)(2) == factory(input_value)(2)
assert bound.bind(factory)(2) == Success(2.5)
assert RCR.from_success(0).bind(
factory,
)(2) == factory(0)(2) == Failure('0')
def test_bind_regular_result():
"""Ensures that regular ``Result`` can be bound."""
def factory(inner_value: int) -> Result[int, str]:
if inner_value > 0:
return Success(inner_value + 1)
return Failure('nope')
first: RCR[int, int, str] = RCR.from_success(1)
third: RCR[int, int, str] = RCR.from_failure('a')
assert first.bind_result(factory)(RCR.empty) == Success(2)
assert RCR.from_success(0).bind_result(
factory,
)(RCR.empty) == Failure('nope')
assert third.bind_result(factory)(RCR.empty) == Failure('a')
def test_rescue_with_context_result():
"""Ensures that functions can be composed and return type is correct."""
rescued = rescue(_context_result_function)
assert rescued(RequiresContextResult.from_success(1), )(1) == Success(1)
assert rescued(RequiresContextResult.from_failure(1), )(1) == Success(2)
assert rescued(
RequiresContextResult.from_failure(0), )(1) == Failure('nope')
def test_requires_context_aliases():
"""Ensures that ReaderResult correctly typecast."""
container: ReaderResultE[int, float] = _function(1)
container2: ReaderResult[int, float, Exception] = _function(1)
container3: ReaderResultE[int, float] = ReaderResultE.from_success(10.0, )
container4: ReaderResultE[int, float] = ReaderResult.from_success(10.0)
assert container(0) == container2(0) == container3(0) == container4(0)
assert container(0) == RequiresContextResult.from_success(10.0)(0)
(IOSuccess(IOSuccess(1)), IOSuccess(1)),
(Some(Some(None)), Nothing),
(Some(Some([])), Some([])),
# Nope:
(Failure(Failure('a')), Failure(Failure('a'))),
(IOFailure(IOFailure('a')), IOFailure(IOFailure('a'))),
])
def test_flatten(container, merged):
"""Ensures that `flatten` is always returning the correct type."""
assert flatten(container) == merged
@pytest.mark.parametrize(('container', 'merged'), [
(
RequiresContextResult.from_success(
RequiresContextResult.from_success(1), ),
RequiresContextResult.from_success(1),
),
(
RequiresContextIOResult.from_success(
RequiresContextIOResult.from_success(1), ),
RequiresContextIOResult.from_success(1),
),
(
RequiresContext.from_value(RequiresContext.from_value(1)),
RequiresContext.from_value(1),
),
])
def test_flatten_context(container, merged):
"""Ensures that `flatten` is always returning the correct type."""
assert flatten(container)(...) == merged(...)
def test_bind_with_context_result():
"""Ensures that functions can be composed and return type is correct."""
binded = bind(_context_result_function)
assert binded(RequiresContextResult.from_success(3))(5) == Success(8)
def test_return_false_with_requires_context_result_container(): # noqa: WPS118
"""Ensures `is_io` function will return False for RequiresContextResult."""
assert is_io(RequiresContextResult.from_success(Success(True))) is False
def test_requires_context_result_immutable():
"""Ensures that container is immutable."""
with pytest.raises(ImmutableStateError):
RequiresContextResult.from_success(1).abc = 1
def _function(arg: int) -> RequiresContextResultE[int, float]:
if arg == 0:
return RequiresContextResult.from_failure(
ZeroDivisionError('Divided by 0'), )
return RequiresContextResult.from_success(10 / arg)
def test_requires_context_resulte():
"""Ensures that RequiresContextResultE correctly typecast."""
container: RequiresContextResult[int, float, Exception] = _function(1)
assert container(0) == RequiresContextResult.from_success(10.0)(0)
def factory(inner_value) -> RCR[int, int, str]:
return RCR.from_success(inner_value * 2)