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)
