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)