def test_should_declare_a_valid_name():
name = Name("Rosalia")
assert_success(name.to_result(),
value_is_instance_of=str,
value_is_equal_to="Rosalia")
def test_should_log_successfully_a_large_type_with_its_repr():
logger = FakeLogger()
class BinaryInfo(NamedTuple):
name: str
data: bytes
def __repr__(self) -> str:
return f"<BinaryInfo {self.name}, len(data)={len(self.data)}>"
@use_case_handler(logger=logger)
class MyUseCase(UseCase):
def execute(self):
binary_info = BinaryInfo(name="my_data", data=b"This are bytes")
return Success(binary_info)
result = MyUseCase().execute()
assert_success(result)
first_logging_message = logger.get_logging_messages()[0]
second_logging_message = logger.get_logging_messages()[1]
assert first_logging_message == (
INFO,
LogMessageMother.get_use_case(operation="MyUseCase", message="Start").to_json(),
)
assert second_logging_message == (
INFO,
LogMessageMother.get_use_case(
operation="MyUseCase", message="<BinaryInfo my_data, len(data)=14>"
).to_json(),
)
def test_should_declare_a_name_with_empty_string():
name = Name("")
assert_success(name.to_result(),
value_is_instance_of=str,
value_is_equal_to="")
def test_should_log_successfully_a_filtered_object_by_blacklist_with_a_tuple(
given_any_petisco
):
logger = FakeLogger()
@use_case_handler(logger=logger, logging_types_blacklist=[tuple])
class MyUseCase(UseCase):
def execute(self):
binary_info = ("my_data", b"This are bytes")
return Success(binary_info)
result = MyUseCase().execute()
assert_success(result)
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 == (
DEBUG,
LogMessageMother.get_use_case(
operation="MyUseCase", message="Success result of type: tuple"
).to_dict(),
)
def test_should_log_successfully_a_filtered_object_by_blacklist_with_python_type_bytest():
logger = FakeLogger()
@use_case_handler(logger=logger, logging_types_blacklist=[bytes])
class MyUseCase(UseCase):
def execute(self):
return Success(b"This are bytes")
result = MyUseCase().execute()
assert_success(result)
first_logging_message = logger.get_logging_messages()[0]
second_logging_message = logger.get_logging_messages()[1]
assert first_logging_message == (
INFO,
LogMessageMother.get_use_case(operation="MyUseCase", message="Start").to_json(),
)
assert second_logging_message == (
INFO,
LogMessageMother.get_use_case(
operation="MyUseCase", message="Object of type: bytes"
).to_json(),
)
def test_should_log_successfully_a_filtered_object_by_blacklist_with_own_named_tuple():
logger = FakeLogger()
class BinaryInfo(NamedTuple):
name: str
data: bytes
@use_case_handler(logger=logger, logging_types_blacklist=[BinaryInfo])
class MyUseCase(UseCase):
def execute(self):
binary_info = BinaryInfo(name="my_data", data=b"This are bytes")
return Success(binary_info)
result = MyUseCase().execute()
assert_success(result)
first_logging_message = logger.get_logging_messages()[0]
second_logging_message = logger.get_logging_messages()[1]
assert first_logging_message == (
INFO,
LogMessageMother.get_use_case(operation="MyUseCase", message="Start").to_json(),
)
assert second_logging_message == (
INFO,
LogMessageMother.get_use_case(
operation="MyUseCase", message="Object of type: BinaryInfo"
).to_json(),
)
def test_should_retrieve_events_successfully_when_empty(
taskmanager_sql_database, given_empty_sql_event_repository):
repository = given_empty_sql_event_repository
result = repository.retrieve_all()
assert_success(result, value_is_equal_to=[])
def test_should_execute_successfully_a_empty_command_without_input_parameters(
given_any_correlation_id):
logger = FakeLogger()
@command_handler(logger=logger)
def my_command(event: Event):
return Success("Hello Petisco")
event = Event({"correlation_id": given_any_correlation_id})
result = my_command(event=event)
assert_success(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 second_logging_message == (
INFO,
LogMessageMother.get_command(
operation="my_command",
message="Result[status: success | value: Hello Petisco]",
correlation_id=given_any_correlation_id,
).to_json(),
)
def test_should_return_a_success_result_with_meiga_decorator():
@meiga
def decorated_method():
return isSuccess
result = decorated_method()
assert_success(result)
def test_should_return_success_user_id_if_generate_user_id_on_meiga_decorated_method(
):
@meiga
def controller():
return Success(UserId.generate())
result = controller()
assert_success(result, value_is_instance_of=UserId)
def test_should_retrieve_task_successfully(
taskmanager_sql_database, given_a_sql_task_repository_with_a_task,
given_any_task_id):
repository = given_a_sql_task_repository_with_a_task
result = repository.retrieve(given_any_task_id)
assert_success(result, value_is_instance_of=Task)
def test_should_remove_task_successfully(
taskmanager_sql_database, given_a_sql_task_repository_with_a_task, given_any_task_id
):
repository = given_a_sql_task_repository_with_a_task
result = repository.remove(given_any_task_id)
assert_success(result)
def test_should_retrieve_events_successfully(
taskmanager_sql_database,
given_a_sql_event_repository_with_some_events):
repository = given_a_sql_event_repository_with_some_events
result = repository.retrieve_all()
assert_success(result)
assert len(result.value) == 3
def test_should_add_elapsed_time_to_results_when_use_timer_decorator():
@timer
def controller():
return Success(({"message": "Ok"}, 200))
result, elapsed_time = controller()
assert_success(result)
assert isinstance(elapsed_time, float)
def test_should_return_a_success_result_with_meiga_decorator_and_static_function_right_order(
):
class MyClass:
@staticmethod
@meiga
def decorated_method() -> BoolResult:
return isSuccess
result = MyClass.decorated_method()
assert_success(result)
def test_should_be_failure_when_execute_a_webhook_and_url_is_not_reachable():
webhook = WebhookMother.default()
sender = WebhookSenderMother.default()
result = sender.execute(webhook, {"payload": "ok"})
assert_success(result, value_is_instance_of=WebhookResult)
webhook_result = result.value
assert not webhook_result.is_success
def test_should_be_failure_when_ping_a_webhook_and_url_is_not_reachable():
webhook = WebhookMother.default()
sender = WebhookSenderMother.default()
result = sender.ping(webhook)
assert_success(result, value_is_instance_of=WebhookResult)
webhook_result = result.value
assert not webhook_result.is_success
def test_should_save_task_successfully(
taskmanager_sql_database,
given_empty_sql_task_repository,
given_any_task_id,
given_any_task,
):
repository = given_empty_sql_task_repository
result = repository.save(given_any_task_id, given_any_task)
assert_success(result)
def test_should_do_complete_onboarding_process(
given_valid_api_key,
given_any_selfie_image_media_data,
given_any_document_front_media_data,
given_any_document_back_media_data,
):
@meiga
def do_complete_onboarding() -> Result[dict, Error]:
config = Config(api_key=given_valid_api_key)
onboarding = Onboarding.from_config(config)
user_id = onboarding.create_user().unwrap_or_return()
onboarding.add_selfie(
user_id=user_id,
media_data=given_any_selfie_image_media_data).unwrap_or_return()
document_id = onboarding.create_document(
user_id=user_id, type="idcard",
issuing_country="ESP").unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=given_any_document_front_media_data,
side="front",
manual=True,
).unwrap_or_return()
onboarding.add_document(
user_id=user_id,
document_id=document_id,
media_data=given_any_document_back_media_data,
side="back",
manual=True,
).handle()
onboarding.document_properties(
user_id=user_id, document_id=document_id).unwrap_or_return()
report = onboarding.create_report(user_id=user_id).unwrap_or_return()
certificate_id = onboarding.create_certificate(
user_id=user_id).unwrap_or_return()
_ = onboarding.retrieve_certificate(
user_id=user_id, certificate_id=certificate_id).unwrap_or_return()
_ = onboarding.retrieve_certificates(
user_id=user_id).unwrap_or_return()
onboarding.delete_user(user_id).unwrap_or_return()
return Success(report)
result = do_complete_onboarding()
assert_success(result, value_is_instance_of=Dict)
def test_should_remove_task_happy_path(given_any_task_id, given_any_task):
mock_task_repository = Mock(spec=ITaskRepository)
mock_task_repository.remove = Mock(return_value=Success(given_any_task))
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_called_once()
assert_success(result)
def test_should_download_a_valid_file_without_auth():
shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
file_setuper = SetupItemFile(base_path="test_deps")
dependency_config = DependencyConfig(
type="file",
url="https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
auth_required=False,
credentials_env=None,
unzip=False,
)
result = file_setuper.run("test-item", dependency_config, EmojisLogger())
assert_success(result)
assert os.path.exists("test_deps/test-item/dummy.pdf")
shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
def test_should_retrieve_events_happy_path(given_some_events):
mock_event_repository = Mock(spec=IEventRepository)
mock_event_repository.retrieve_all = Mock(
return_value=Success(given_some_events))
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_called_once()
assert_success(result)
def test_should_download_a_valid_bucket_with_auth_and_overwrite():
file_setuper = SetupItemBucket(base_path="test_deps")
dependency_config = DependencyConfig(
type="bucket",
url="gs://aliceonboarding/-AmBH6e1JnNcFPej9Bcvp5EJRCI=.jpg",
auth_required=True,
credentials_env="GCS_CREDENTIALS",
unzip=False,
overwrite=True)
result = file_setuper.run("test-item", dependency_config, EmojisLogger())
assert_success(result)
assert os.path.exists(
"test_deps/test-item/-AmBH6e1JnNcFPej9Bcvp5EJRCI=.jpg")
shutil.rmtree("test_deps", ignore_errors=False, onerror=None)
def test_should_download_a_valid_zip_without_auth():
shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
file_setuper = SetupItemFile(base_path="test_deps")
dependency_config = DependencyConfig(
type="file",
url="https://file-examples.com/wp-content/uploads/2017/02/zip_2MB.zip",
auth_required=False,
credentials_env=None,
unzip=True,
)
result = file_setuper.run("test-item", dependency_config, EmojisLogger())
assert_success(result)
assert len(os.listdir("test_deps/test-item")) > 0
assert not os.path.exists("test_deps/test-item/zip_2MB.zip")
shutil.rmtree("test_deps", ignore_errors=True, onerror=None)
def test_should_create_task_happy_path(given_any_task_id, given_any_title,
given_any_description):
mock_task_repository = Mock(spec=ITaskRepository)
mock_task_repository.save = Mock(return_value=isSuccess)
mock_event_publisher = Mock(spec=IEventPublisher)
use_case = CreateTask(mock_task_repository, mock_event_publisher)
result = use_case.execute(given_any_task_id, given_any_title,
given_any_description)
mock_task_repository.save.assert_called_once()
mock_event_publisher.publish_events.assert_called_once()
assert_success(result)
def test_should_log_successfully_a_non_error_use_case_with_input_parameters(
given_any_petisco
):
logger = FakeLogger()
@use_case_handler(
logger=logger, logging_parameters_whitelist=["client_id", "user_id"]
)
class MyUseCase(UseCase):
def execute(self, client_id: str, user_id: str):
return Success("Hello Petisco")
result = MyUseCase().execute(client_id="client_id", user_id="user_id")
assert_success(result)
first_logging_message = logger.get_logging_messages()[0]
second_logging_message = logger.get_logging_messages()[1]
third_logging_message = logger.get_logging_messages()[2]
assert first_logging_message == (
DEBUG,
LogMessageMother.get_use_case(
operation="MyUseCase", message="Running Use Case"
).to_dict(),
)
assert second_logging_message == (
DEBUG,
LogMessageMother.get_use_case(
operation="MyUseCase",
message={"client_id": "client_id", "user_id": "user_id"},
).to_dict(),
)
assert third_logging_message == (
DEBUG,
LogMessageMother.get_use_case(
operation="MyUseCase", message="Hello Petisco"
).to_dict(),
)
def test_should_create_a_user_and_get_user_token_and_delete_it(
given_valid_sandbox_token, given_any_valid_mail):
config = Config(sandbox_token=given_valid_sandbox_token)
sandbox = Sandbox.from_config(config)
result_create_user = sandbox.create_user(user_info=UserInfo(
email=given_any_valid_mail))
assert_success(result_create_user)
result_user_token = sandbox.get_user_token(email=given_any_valid_mail)
assert_success(result_user_token)
result_delete_user = sandbox.delete_user(email=given_any_valid_mail)
assert_success(result_delete_user)
def test_should_declare_a_name_with_none_string():
# This is quite typical using frameworks as connexion
name = Name("None")
assert_success(name.to_result(), value_is_equal_to=None)
def test_should_declare_a_client_id_with_empty_string():
client_id = ClientId("")
assert_success(
client_id.to_result(), value_is_instance_of=str, value_is_equal_to=""
)
def test_should_declare_a_valid_client_id():
client_id = ClientId("Acme")
assert_success(
client_id.to_result(), value_is_instance_of=str, value_is_equal_to="Acme"
)
