feat: TT-418 create tests added

V2/tests/api/azure/customer_azure_endpoints_test.py

@@ -0,0 +1,49 @@
+import json
+from faker import Faker
+
+import azure.functions as func
+
+import time_tracker.customers._application._customers as azure_customers
+
+CUSTOMER_URL = "/api/customers/"
+
+
+def test__customer_azure_endpoint__creates_a_customer__when_customer_has_all_necesary_attributes(
+    customer_factory
+):
+    customer_body = customer_factory().__dict__
+
+    body = json.dumps(customer_body).encode("utf-8")
+    req = func.HttpRequest(
+        method='POST',
+        body=body,
+        url=CUSTOMER_URL,
+    )
+
+    response = azure_customers._create_customer.create_customer(req)
+    customer_json_data = json.loads(response.get_body())
+    customer_body['id'] = customer_json_data['id']
+
+    assert response.status_code == 201
+    assert customer_json_data == customer_body
+
+
+def test__customer_azure_endpoint__returns_a_status_400__when_dont_recieve_all_necessary_attributes():
+    customer_to_insert = {
+        "id": None,
+        "name": Faker().user_name(),
+        "deleted": False,
+        "status": 1
+    }
+
+    body = json.dumps(customer_to_insert).encode("utf-8")
+    req = func.HttpRequest(
+        method='POST',
+        body=body,
+        url=CUSTOMER_URL,
+    )
+
+    response = azure_customers._create_customer.create_customer(req)
+
+    assert response.status_code == 400
+    assert response.get_body() == b'Invalid format or structure of the attributes of the customer'

V2/tests/conftest.py

@@ -1,3 +1,4 @@
 # flake8: noqa
 from fixtures import _activity_factory, _test_db, _insert_activity
 from fixtures import _time_entry_factory
+from fixtures import _customer_factory

V2/tests/fixtures.py

@@ -2,8 +2,9 @@
 from faker import Faker
 
 import time_tracker.activities._domain as activities_domain
-import time_tracker.activities._infrastructure as activities_infrastructure
 import time_tracker.time_entries._domain as time_entries_domain
+import time_tracker.customers._domain as customers_domain
+import time_tracker.activities._infrastructure as activities_infrastructure
 from time_tracker._infrastructure import DB
 
 
@@ -73,3 +74,23 @@ def _new_activity(activity: activities_domain.Activity, database: DB):
         new_activity = dao.create(activity)
         return new_activity
     return _new_activity
+
+
+@pytest.fixture(name='customer_factory')
+def _customer_factory() -> customers_domain.Customer:
+    def _make_customer(
+        name: str = Faker().name(),
+        description: str = Faker().sentence(),
+        deleted: bool = False,
+        status: int = 1,
+    ):
+        customer = customers_domain.Customer(
+            id=None,
+            name=name,
+            description=description,
+            deleted=deleted,
+            status=status
+            )
+        return customer
+
+    return _make_customer

V2/tests/integration/daos/customers_dao_test.py

@@ -0,0 +1,35 @@
+import pytest
+
+import time_tracker.customers._domain as domain
+import time_tracker.customers._infrastructure as infrastructure
+from time_tracker._infrastructure import DB
+
+
+@pytest.fixture(name='create_fake_dao')
+def _fake_dao() -> domain.CustomersDao:
+    def _create_fake_dao(db_fake: DB) -> domain.CustomersDao:
+        dao = infrastructure.CustomersSQLDao(db_fake)
+        return dao
+    return _create_fake_dao
+
+
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB()
+    dao = infrastructure.CustomersSQLDao(db_fake)
+    query = dao.customer.delete()
+    dao.db.get_session().execute(query)
+
+
+def test__customer_dao__returns_a_customer_dto__when_saves_correctly_with_sql_database(
+    test_db, customer_factory, create_fake_dao
+):
+    dao = create_fake_dao(test_db)
+
+    customer_to_insert = customer_factory()
+
+    inserted_customer = dao.create(customer_to_insert)
+
+    assert isinstance(inserted_customer, domain.Customer)
+    assert inserted_customer == customer_to_insert

V2/tests/unit/services/customer_service_test.py

@@ -0,0 +1,14 @@
+from time_tracker.customers._domain import CustomerService
+
+
+def test__create_customer__uses_the_customer_dao__to_create_a_customer(mocker, customer_factory):
+    expected_customer = mocker.Mock()
+    customer_dao = mocker.Mock(
+        create=mocker.Mock(return_value=expected_customer)
+    )
+    customer_service = CustomerService(customer_dao)
+
+    new_customer = customer_service.create(customer_factory())
+
+    assert customer_dao.create.called
+    assert expected_customer == new_customer

V2/tests/unit/use_cases/customers_use_case_test.py

@@ -0,0 +1,18 @@
+from pytest_mock import MockFixture
+
+from time_tracker.customers._domain import _use_cases
+
+
+def test__create_customer_function__uses_the_customer_service__to_create_a_customer(
+    mocker: MockFixture, customer_factory
+):
+    expected_customer = mocker.Mock()
+    customer_service = mocker.Mock(
+        create=mocker.Mock(return_value=expected_customer)
+    )
+
+    customer_use_case = _use_cases.CreateCustomerUseCase(customer_service)
+    new_customer = customer_use_case.create_customer(customer_factory())
+
+    assert customer_service.create.called
+    assert expected_customer == new_customer

V2/time_tracker/customers/_application/__init__.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-from ._time_entries import create_customer
+from ._customers import create_customer

V2/time_tracker/customers/_application/_customers/_create_customer.py

@@ -0,0 +1,56 @@
+import dataclasses
+import json
+
+import azure.functions as func
+
+from ... import _domain
+from ... import _infrastructure
+from time_tracker._infrastructure import DB
+
+DEFAULT_FIELDS = ["id", "deleted", "status"]
+
+
+def create_customer(req: func.HttpRequest) -> func.HttpResponse:
+    try:
+        database = DB()
+        customer_dao = _infrastructure.CustomersSQLDao(database)
+        customer_service = _domain.CustomerService(customer_dao)
+        use_case = _domain._use_cases.CreateCustomerUseCase(customer_service)
+        customer_data = req.get_json()
+
+        customer_is_valid = _validate_customer(customer_data)
+        if not customer_is_valid:
+            raise ValueError
+
+        customer_to_create = _domain.Customer(
+            **dict.fromkeys(DEFAULT_FIELDS),
+            name=str(customer_data["name"]).strip(),
+            description=str(customer_data["description"]),
+        )
+        created_customer = use_case.create_customer(customer_to_create)
+
+        if created_customer:
+            body = json.dumps(created_customer.__dict__)
+            status_code = 201
+        else:
+            body = b'This customer already exists'
+            status_code = 409
+
+        return func.HttpResponse(
+            body=body,
+            status_code=status_code,
+            mimetype="application/json"
+        )
+    except ValueError:
+        return func.HttpResponse(
+            body=b'Invalid format or structure of the attributes of the customer',
+            status_code=400,
+            mimetype="application/json"
+        )
+
+
+def _validate_customer(customer_data: dict) -> bool:
+    if [field.name for field in dataclasses.fields(_domain.Customer)
+            if (field.name not in customer_data) and (field.name not in DEFAULT_FIELDS)]:
+        return False
+    return True

V2/time_tracker/customers/_domain/__init__.py

@@ -4,8 +4,4 @@
 from ._services import CustomerService
 from ._use_cases import (
     CreateCustomerUseCase,
-    UpdateCustomerUseCase,
-    GetAllCustomerUseCase,
-    GetByIdCustomerUseCase,
-    DeleteCustomerUseCase
 )

V2/time_tracker/customers/_domain/_persistence_contracts/_customers_dao.py

@@ -1,5 +1,4 @@
 import abc
-import typing
 
 from time_tracker.customers._domain import Customer
 
@@ -8,19 +7,3 @@ class CustomersDao(abc.ABC):
     @abc.abstractmethod
     def create(self, data: Customer) -> Customer:
         pass
-
-    # @abc.abstractmethod
-    # def update(self, data: Customer) -> Customer:
-    #     pass
-
-    # @abc.abstractmethod
-    # def get_by_id(self, id: int) -> Customer:
-    #     pass
-
-    # @abc.abstractmethod
-    # def get_all(self) -> typing.List[Customer]:
-    #     pass
-
-    # @abc.abstractmethod
-    # def delete(self, id: int) -> Customer:
-    #     pass

V2/time_tracker/customers/_domain/_services/_customer.py

@@ -1,5 +1,3 @@
-import typing
-
 from time_tracker.customers._domain import Customer, CustomersDao
 
 
@@ -10,15 +8,3 @@ def __init__(self, customer_dao: CustomersDao):
 
     def create(self, data: Customer) -> Customer:
         return self.customer_dao.create(data)
-
-    # def update(self, data: Customer) -> Customer:
-    #     return self.customer_dao.update(data)
-
-    # def get_by_id(self, id: int) -> Customer:
-    #     return self.customer_dao.get_by_id(id)
-
-    # def get_all(self) -> typing.List[Customer]:
-    #     return self.customer_dao.get_all()
-
-    # def delete(self, id: int) -> Customer:
-    #     return self.customer_dao.delete(id)

V2/time_tracker/customers/_domain/_use_cases/__init__.py

@@ -1,6 +1,2 @@
 # flake8: noqa
-from ._create_customer_use_case import CreateCustomerUseCase
-from ._update_customer_use_case import UpdateCustomerUseCase
-from ._get_by_id_customer_use_case import GetByIdCustomerUseCase
-from ._get_all_customer_use_case import GetAllCustomerUseCase
-from ._delete_customer_use_case import DeleteCustomerUseCase
+from ._create_customer_use_case import CreateCustomerUseCase