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_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_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_ioresult(): """Ensures that functions can be composed and return type is correct.""" rescued = rescue(_context_ioresult_function) assert rescued(RequiresContextIOResult.from_value(1), )(1) == IOSuccess(1) assert rescued( RequiresContextIOResult.from_failure(1), )(1) == IOSuccess(2) assert rescued( RequiresContextIOResult.from_failure(0), )(1) == IOFailure('nope')
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) == IOSuccess(0.5) assert RCR.from_value(2).bind_context(factory, )(1) == IOSuccess(2.0) assert third.bind_context(factory)(1) == IOFailure('a')
def test_bind_result_context(): """Ensures that ``RequiresContextResult`` can be bound.""" def factory(inner_value: int) -> RequiresContextResult[int, float, str]: return RequiresContextResult(lambda deps: Success(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_result(factory)(2) == IOSuccess(0.5) assert RCR.from_success(2).bind_context_result( factory, )(1) == IOSuccess(2.0) assert third.bind_context_result(factory)(1) == IOFailure('a')
def test_bind_ioresult(): """Ensures that io ``Result`` can be bound.""" def factory(inner_value: int) -> IOResult[int, str]: if inner_value > 0: return IOSuccess(inner_value + 1) return IOFailure('nope') first: RCR[int, str, int] = RCR.from_value(1) third: RCR[int, str, int] = RCR.from_failure('a') assert first.bind_ioresult(factory)(RCR.empty) == IOSuccess(2) assert RCR.from_value(0).bind_ioresult(factory, )( RCR.empty) == IOFailure('nope') assert third.bind_ioresult(factory)(RCR.empty) == IOFailure('a')
def test_bind(): """Ensures that bind works.""" def factory(inner_value: int) -> RCR[float, str, int]: if inner_value > 0: return RCR(lambda deps: IOSuccess(inner_value / deps)) return RCR.from_failure(str(inner_value)) input_value = 5 bound: RCR[int, str, int] = RCR.from_value(input_value) assert bound.bind(factory)(2) == factory(input_value)(2) assert bound.bind(factory)(2) == IOSuccess(2.5) assert RCR.from_value(0).bind( factory, )(2) == factory(0)(2) == IOFailure('0')
def _reader_ioresult_pipeline(self, inner_value): def factory(deps): return _managed( lambda inner: self._use(inner)(deps), lambda inner, pure: self._release(inner, pure)(deps), )(IOResult.from_value(inner_value)) return RequiresContextIOResult(factory)
def test_requires_context_io_aliases(): """Ensures that ReaderIOResult correctly typecast.""" container: ReaderIOResultE[int, float] = _function(1) container2: ReaderIOResult[int, float, Exception] = _function(1) container3: ReaderIOResultE[int, float] = ReaderIOResultE.from_value(10.0, ) container4: ReaderIOResultE[int, float] = ReaderIOResult.from_value(10.0) assert container(0) == container2(0) == container3(0) == container4(0) assert container(0) == RequiresContextIOResult.from_value(10.0)(0)
def _function(arg: int) -> RequiresContextIOResultE[int, float]: if arg == 0: return RequiresContextIOResult.from_failure( ZeroDivisionError('Divided by 0'), ) return RequiresContextIOResult.from_value(10 / arg)
def test_requires_context_ioresulte(): """Ensures that RequiresContextIOResultE correctly typecast.""" container: RequiresContextIOResult[int, float, Exception] = _function(1) assert container(0) == RequiresContextIOResult.from_value(10.0)(0)
def factory(inner_value) -> RCR[int, int, str]: return RCR.from_value(inner_value * 2)
(IOFailure(IOFailure('a')), IOFailure(IOFailure('a'))), (IOFailure(IOSuccess('a')), IOFailure(IOSuccess('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_value( RequiresContextResult.from_value(1), ), RequiresContextResult.from_value(1), ), ( RequiresContextIOResult.from_value( RequiresContextIOResult.from_value(1), ), RequiresContextIOResult.from_value(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(...) @pytest.mark.anyio() async def test_flatten_future(subtests): """Ensures that `flatten` is always returning the correct type."""
def factory(inner_value: int) -> RCR[float, str, int]: if inner_value > 0: return RCR(lambda deps: IOSuccess(inner_value / deps)) return RCR.from_failure(str(inner_value))
def factory(inner_value) -> RCR[int, str, int]: return RCR.from_failure(inner_value * 2)
def _context_ioresult_function( argument: int, ) -> RequiresContextIOResult[int, int, str]: if argument > 0: return RequiresContextIOResult(lambda deps: IOSuccess(argument + deps)) return RequiresContextIOResult.from_failure('nope')
def test_return_true_with_requires_context_io_result_container( ): # noqa: E501,WPS118 """Ensures `is_io` function will return True for RequiresContextIOResult.""" assert is_io(RequiresContextIOResult.from_success(1.5)) is True
def test_requires_context_result_immutable_deepcopy(): # noqa: WPS118 """Ensures that helper returns it self when passed to deepcopy function.""" requires_context = RequiresContextIOResult.from_success(1) assert requires_context is deepcopy(requires_context)
def test_requires_context_result_immutable_copy(): """Ensures that helper returns it self when passed to copy function.""" context_ioresult = RequiresContextIOResult.from_value(1) assert context_ioresult is copy(context_ioresult)
def test_bind_with_context_io_result(): """Ensures that functions can be composed and return type is correct.""" binded = bind(_context_io_result_function) assert binded(RequiresContextIOResult.from_success(3))(5) == IOSuccess(8)
def test_apply_with_context_ioresult(): """Ensures that functions can be composed and return type is correct.""" applied = apply(RequiresContextIOResult.from_value(_function)) assert applied(RequiresContextIOResult.from_value(1), )( ...) == IOSuccess('2')
from returns.io import IOFailure, IOSuccess from returns.primitives.exceptions import ImmutableStateError from returns.primitives.interfaces import ( Altable, Bindable, Fixable, Mappable, Rescueable, Unitable, Unwrapable, ) from returns.result import Failure, Success @pytest.mark.parametrize('container', [ RequiresContextIOResult(lambda _: IOSuccess(1)), RequiresContextIOResult(lambda _: IOFailure(1)), RequiresContextIOResult.from_success(1), RequiresContextIOResult.from_failure(1), RequiresContextIOResult.from_result(Success(1)), RequiresContextIOResult.from_result(Failure(1)), RequiresContextIOResult.from_ioresult(IOSuccess(1)), RequiresContextIOResult.from_ioresult(IOFailure(1)), ContextIOResult.ask(), ]) @pytest.mark.parametrize('protocol', [ Bindable, Mappable, Rescueable, Unwrapable, Altable,
def _under_test( container, *, should_lash: bool = False, ): if should_lash: return container.lash(lambda inner: container.from_failure(inner)) return container.bind(lambda inner: container.from_value(inner)) @pytest.mark.parametrize('container', [ Success(1), Failure(1), IOSuccess(1), IOFailure(1), RequiresContextIOResult.from_value(1), RequiresContextIOResult.from_failure(1), RequiresContextFutureResult.from_value(1), RequiresContextFutureResult.from_failure(1), RequiresContextResult.from_value(1), RequiresContextResult.from_failure(1), FutureResult.from_value(1), FutureResult.from_failure(1), ]) @pytest.mark.parametrize('kwargs', [ { 'should_lash': True }, ]) def test_error_handled(container, returns, kwargs): """Demo on how to use ``pytest`` helpers to work with error handling."""
def _context_io_result_function( argument: int, ) -> RequiresContextIOResult[int, int, str]: return RequiresContextIOResult(lambda other: IOSuccess(argument + other))
def test_requires_context_result_immutable(): """Ensures that container is immutable.""" with pytest.raises(ImmutableStateError): RequiresContextIOResult.from_success(1).abc = 1
(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(...)
should_rescue: bool = False, should_fix: bool = False, ): if should_rescue: return container.rescue(lambda inner: container.from_failure(inner)) if should_fix: return container.fix(identity) return container.bind(lambda inner: container.from_success(inner)) @pytest.mark.parametrize('container', [ Success(1), Failure(1), IOSuccess(1), IOFailure(1), RequiresContextIOResult.from_success(1), RequiresContextIOResult.from_failure(1), RequiresContextResult.from_success(1), RequiresContextResult.from_failure(1), ]) @pytest.mark.parametrize('kwargs', [ {'should_rescue': True}, {'should_fix': True}, {'should_rescue': True, 'should_fix': True}, ]) def test_error_handled(container, returns, kwargs): """Demo on how to use ``pytest`` helpers to work with error handling.""" error_handled = _under_test(container, **kwargs) assert returns.is_error_handled(error_handled) assert returns.is_error_handled(error_handled.map(identity))