def test_should_fail_when_request_method_raise_unauthorized_error( method, given_any_url): with requests_mock.Mocker() as m: m.register_uri(method, given_any_url, status_code=401) result = Request.execute(given_any_url, method) assert_failure(result, value_is_instance_of=UnauthorizedRequestError) assert result.value.status_code == 401
def test_should_fail_when_request_method_returns_unknown_error_when_raise_an_uncontrolled_exception( method, given_any_url): with requests_mock.Mocker() as m: m.register_uri(method, given_any_url, exc=InterruptedError) result = Request.execute(given_any_url, method) assert_failure(result, value_is_instance_of=UnknownRequestError) assert result.value.status_code == 500
def test_should_log_successfully_an_error_raised_by_a_meiga_handler(given_any_petisco): logger = FakeLogger() class UserNotFoundError(Error): pass @use_case_handler(logger=logger) class MyUseCase(UseCase): def execute(self): Failure(UserNotFoundError()).unwrap_or_return() return isSuccess result = MyUseCase().execute() assert_failure(result, value_is_instance_of=UserNotFoundError) first_logging_message = logger.get_logging_messages()[0] second_logging_message = logger.get_logging_messages()[1] assert first_logging_message == ( DEBUG, LogMessageMother.get_use_case( operation="MyUseCase", message="Running Use Case" ).to_dict(), ) assert second_logging_message == ( ERROR, LogMessageMother.get_use_case( operation="MyUseCase", message="Result[status: failure | value: UserNotFoundError] ", ).to_dict(), )
def test_should_capture_an_exception_with_additional_context(): expected_trace = "my_trace" expected_raised_exception = RuntimeError(expected_trace) def inner(): raise expected_raised_exception @meiga def method(): try: inner() except Exception as exception: raise CriticalError( exception=exception, executor="executor", traceback=traceback.format_exc(), ) result = method() assert_failure( result, value_is_instance_of=CriticalError, value_is_equal_to=CriticalError(expected_raised_exception), ) assert result.value.executor == "executor" assert "Traceback" in result.value.traceback assert "File" in result.value.traceback assert "Traceback" in str(result)
def test_should_fail_when_request_method_returns_unknown_error( method, status_code, given_any_url): with requests_mock.Mocker() as m: m.register_uri(method, given_any_url, status_code=status_code) result = Request.execute(given_any_url, method) assert_failure(result, value_is_instance_of=UnknownRequestError) assert result.value.status_code == status_code
def test_should_use_case_handler_return_a_failure_with_unknown_error_when_raise_an_uncontrolled_exception( given_any_petisco ): logger = FakeLogger() expected_raised_exception = RuntimeError("uncontrolled exception") @use_case_handler(logger=logger) class MyUseCase(UseCase): def execute(self): raise expected_raised_exception result = MyUseCase().execute() assert_failure( result, value_is_instance_of=UnknownError, value_is_equal_to=UnknownError(expected_raised_exception), ) first_logging_message = logger.get_logging_messages()[0] second_logging_message = logger.get_logging_messages()[1] assert first_logging_message == ( DEBUG, LogMessageMother.get_use_case( operation="MyUseCase", message="Running Use Case" ).to_dict(), ) assert ( "value: UnknownError (MyUseCase (Use Case)): RuntimeError: uncontrolled exception.\nTraceback (most recent call last):\n File" in second_logging_message[1]["data"]["message"] )
def test_should_log_successfully_an_error_returned_on_a_use_case(given_any_petisco): logger = FakeLogger() @use_case_handler(logger=logger) class MyUseCase(UseCase): def execute(self): return isFailure result = MyUseCase().execute() assert_failure(result, value_is_instance_of=Error) first_logging_message = logger.get_logging_messages()[0] second_logging_message = logger.get_logging_messages()[1] assert first_logging_message == ( DEBUG, LogMessageMother.get_use_case( operation="MyUseCase", message="Running Use Case" ).to_dict(), ) assert second_logging_message == ( ERROR, LogMessageMother.get_use_case( operation="MyUseCase", message="Result[status: failure | value: Error] " ).to_dict(), )
def test_should_return_failure_result_when_an_exception_raises_within_command( given_any_correlation_id): logger = FakeLogger() @command_handler(logger=logger) def my_command(event: Event): raise RuntimeError("my_command exception") event = Event({"correlation_id": given_any_correlation_id}) result = my_command(event=event) assert_failure(result) first_logging_message = logger.get_logging_messages()[0] second_logging_message = logger.get_logging_messages()[1] assert first_logging_message == ( INFO, LogMessageMother.get_command( operation="my_command", message=f"Event received: {event}", correlation_id=given_any_correlation_id, ).to_json(), ) assert "line" in second_logging_message[1] assert "RuntimeError" in second_logging_message[1] assert "my_command exception" in second_logging_message[1]
def test_should_declare_a_name_that_exceeds_default_length_limits(): name = Name( 'Rosalia de Castro: "Adios rios adios fontes; adios, regatos pequenos; adios, vista dos meus ollos: non sei cando nos veremos."' ) assert_failure(name.to_result(), value_is_instance_of=InputExceedLengthLimitError)
def test_should_fail_user_id_when_declare_a_non_valid_user_id(value): @meiga def controller(): user_id = UserId(value) return Success(user_id) result = controller() assert_failure(result, value_is_instance_of=InvalidUuidError)
def test_should_return_an_error_when_the_api_key_is_not_configured(): config = Config() onboarding = Onboarding.from_config(config) result = onboarding.create_user() assert_failure(result)
def test_should_fail_when_retrieve_task_when_task_is_not_found( taskmanager_sql_database, given_empty_sql_task_repository, given_any_task_id): repository = given_empty_sql_task_repository result = repository.remove(given_any_task_id) assert_failure(result, value_is_instance_of=TaskNotFoundError)
def test_should_return_a_failure_result_with_meiga_decorator(): @meiga def decorated_method(): return isFailure result = decorated_method() assert_failure(result)
def test_should_return_an_error_when_the_sandbox_token_is_not_configured(): config = Config() sandbox = Sandbox.from_config(config) result = sandbox.create_user() assert_failure(result)
def test_should_fail_when_declare_a_non_valid_client_id_call_guard(): @meiga def controller(): user_id = ClientId("<script>evil()</script>") return Success(user_id) result = controller() assert_failure(result, value_is_instance_of=GivenInputIsNotValidError)
def test_should_declare_a_name_that_exceeds_default_length_limits(): client_id = ClientId( "La Corporación Acme es una empresa ficticia, que existe en el universo de los Looney Tunes. Apareció la mayor cantidad de veces en las caricaturas de El Coyote y el Correcaminos, que hicieron famosa a Acme por sus productos peligrosos y poco reales, los cuales fallaban catastróficamente de las peores maneras." ) assert_failure( client_id.to_result(), value_is_instance_of=InputExceedLengthLimitError )
def test_should_return_an_error_when_the_api_key_is_not_configured(): config = Config() auth = Auth.from_config(config) result = auth.create_backend_token() assert_failure(result)
def test_should_fail_when_declare_a_no_valid_name_on_a_meiga_decorated_method(): @meiga def controller(): name = Name("<script>evil()</script>") return Success(name) result = controller() assert_failure(result, value_is_instance_of=GivenNameIsNotValidError)
def test_should_fail_when_request_method_returns_missing_schema_error( method, given_any_url): with requests_mock.Mocker() as m: m.register_uri(method, given_any_url, exc=requests.exceptions.MissingSchema) result = Request.execute(given_any_url, method) assert_failure(result, value_is_instance_of=MissingSchemaRequestError) assert result.value.status_code == 422
def test_should_return_a_failure_result_with_meiga_decorator_when_raise_an_error( ): @meiga def decorated_method(): raise Error() result = decorated_method() assert_failure(result, value_is_instance_of=Error)
def test_should_fail_when_request_method_returns_connection_error( method, given_any_url): with requests_mock.Mocker() as m: m.register_uri(method, given_any_url, exc=requests.exceptions.ConnectionError) result = Request.execute(given_any_url, method) assert_failure(result, value_is_instance_of=ConnectionRequestError) assert result.value.status_code == 503
def test_should_fail_when_declare_a_large_name_on_a_meiga_decorated_method(): @meiga def controller(): name = Name( "Rosalia de Castro. Adios rios adios fontes, adios, regatos pequenos, adios, vista dos meus ollos, non sei cando nos veremos." ) return Success(name) result = controller() assert_failure(result, value_is_instance_of=ExceedLengthLimitValueObjectError)
def test_should_fail_when_save_task_when_already_exist_the_task( taskmanager_sql_database, given_a_sql_task_repository_with_a_task, given_any_task_id, given_any_task, ): repository = given_a_sql_task_repository_with_a_task result = repository.save(given_any_task_id, given_any_task) assert_failure(result, value_is_instance_of=TaskAlreadyExistError)
def test_should_return_a_failure_result_with_meiga_decorator_when_raise_an_error_subclass( ): class MyError(Error): def __init__(self, message): self.message = message @meiga def decorated_method(): raise MyError("message") result = decorated_method() assert_failure(result, value_is_instance_of=MyError)
def test_should_return_error_when_credentials_not_provided(): shutil.rmtree("test_deps", ignore_errors=True, onerror=None) file_setuper = SetupItemFile(base_path="test_deps") dependency_config = DependencyConfig( type="file", url="https://intranet.gradiant.org/nexus/repository/raw-dataset-biometrics/alice/gcs-credentials.json", auth_required=True, credentials_env="LOL", unzip=False, ) result = file_setuper.run("test-item", dependency_config, EmojisLogger()) assert_failure(result, value_is_instance_of=CrendentialsEnvError) shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
def test_should_return_task_not_found_error(): mock_event_repository = Mock(spec=IEventRepository) mock_event_repository.retrieve_all = Mock(return_value=isFailure) mock_event_publisher = Mock(spec=IEventPublisher) use_case = EventsRetriever(mock_event_repository, mock_event_publisher) result = use_case.execute() mock_event_repository.retrieve_all.assert_called_once() mock_event_publisher.publish.assert_not_called() assert_failure(result)
def test_should_return_a_unexpected_decorator_order_failure_result_with_meiga_decorator_and_static_method( ): class MyClass: @meiga @staticmethod def decorated_method() -> BoolResult: return isSuccess result = MyClass.decorated_method() assert_failure(result, value_is_instance_of=UnexpectedDecorationOrderError) assert ( result.value.message == "@meiga decorator must be declared after a @staticmethod, @classmethod" )
def test_should_return_error_when_wrong_bucket_name(): shutil.rmtree("test_deps", ignore_errors=True, onerror=None) file_setuper = SetupItemBucket(base_path="test_deps") dependency_config = DependencyConfig( type="bucket", url="gs://soyunbucket/-AmBH6e1JnNcFPej9Bcvp5EJRCI=.jpg", auth_required=True, credentials_env="GCS_CREDENTIALS", unzip=False, ) result = file_setuper.run("test-item", dependency_config, EmojisLogger()) assert_failure(result) assert isinstance(result.value, BlobNotFoundError) shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
def test_should_return_error_when_credentials_not_define(): shutil.rmtree("test_deps", ignore_errors=True, onerror=None) file_setuper = SetupItemBucket(base_path="test_deps") dependency_config = DependencyConfig( type="bucket", url="gs://aliceonboarding/-AmBH6e1JnNcFPej9Bcvp5EJRCI=.jpg", auth_required=True, credentials_env="SOME_CREDENTIAL", unzip=False, ) result = file_setuper.run("test-item", dependency_config, EmojisLogger()) assert_failure(result) assert isinstance(result.value, CrendentialsEnvError) shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
def test_should_return_task_not_found_error(given_any_task_id, given_any_task): mock_task_repository = Mock(spec=ITaskRepository) mock_task_repository.remove = Mock( return_value=Failure(TaskNotFoundError(given_any_task_id))) mock_event_publisher = Mock(spec=IEventPublisher) use_case = TaskRemover(mock_task_repository, mock_event_publisher) result = use_case.execute(given_any_task_id) mock_task_repository.remove.assert_called_once() mock_event_publisher.publish.assert_not_called() assert_failure(result, value_is_instance_of=TaskNotFoundError)