def test_rescue_failure():
"""Ensures that rescue works for Failure container."""
def factory(inner_value) -> RCR[int, str, int]:
return RCR.from_failure(inner_value * 2)
assert RCR.from_value(5).rescue(factory, )(0) == RCR.from_value(5)(0)
assert RCR.from_failure(5).rescue(factory, )(0) == RCR.from_failure(10)(0)
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_value(1), )(1) == Success(1)
assert rescued(RequiresContextResult.from_failure(1), )(1) == Success(2)
assert rescued(
RequiresContextResult.from_failure(0), )(1) == Failure('nope')
def test_lash_success():
"""Ensures that lash works for Success container."""
def factory(inner_value) -> RCR[int, str, int]:
return RCR.from_value(inner_value * 2)
assert RCR.from_value(5).lash(factory, )(0) == RCR.from_value(5)(0)
assert RCR.from_failure(5).lash(factory, )(0) == RCR.from_value(10)(0)
def test_rescue_success():
"""Ensures that rescue works for Success container."""
def factory(inner_value) -> RCR[int, int, str]:
return RCR.from_success(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_success(10)(0)
def test_bind_regular_context():
"""Ensures that regular ``RequiresContext`` can be bound."""
def factory(inner_value: int) -> RequiresContext[float, int]:
return RequiresContext(lambda deps: inner_value / deps)
first: RCR[int, str, int] = RCR.from_value(1)
third: RCR[int, str, int] = RCR.from_failure('a')
assert first.bind_context(factory)(2) == Success(0.5)
assert RCR.from_value(2).bind_context(factory, )(1) == Success(2.0)
assert third.bind_context(factory)(1) == Failure('a')
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, str, int] = RCR.from_value(1)
third: RCR[int, str, int] = RCR.from_failure('a')
assert first.bind_result(factory)(RCR.empty) == Success(2)
assert RCR.from_value(0).bind_result(factory, )(
RCR.empty) == Failure('nope')
assert third.bind_result(factory)(RCR.empty) == Failure('a')
def _context_result_function(
argument: int, ) -> RequiresContextResult[int, int, str]:
if argument > 0:
return RequiresContextResult(lambda deps: Success(argument + deps))
return RequiresContextResult.from_failure('nope')
def _function(arg: int) -> RequiresContextResultE[float, int]:
if arg == 0:
return RequiresContextResult.from_failure(
ZeroDivisionError('Divided by 0'), )
return RequiresContextResult.from_value(10 / arg)
Altable,
Bindable,
Fixable,
Mappable,
Rescueable,
Unitable,
Unwrapable,
)
from returns.result import Failure, Success
@pytest.mark.parametrize('container', [
RequiresContextResult(lambda _: Success(1)),
RequiresContextResult(lambda _: Failure(1)),
RequiresContextResult.from_success(1),
RequiresContextResult.from_failure(1),
RequiresContextResult.from_result(Success(1)),
RequiresContextResult.from_result(Failure(1)),
ContextResult.ask(),
])
@pytest.mark.parametrize('protocol', [
Bindable,
Mappable,
Rescueable,
Unwrapable,
Altable,
Fixable,
Unitable,
])
def test_protocols(container, protocol):
"""Ensures that RequiresContext has all the right protocols."""
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))
def factory(inner_value) -> RCR[int, int, str]:
return RCR.from_failure(inner_value * 2)