feat: TT-418 create tests added

V2/tests/api/azure/customer_azure_endpoints_test.py

@@ -0,0 +1,54 @@
+import pytest
+import json
+from faker import Faker
+
+import azure.functions as func
+
+import time_tracker.customers._application._customers as azure_customers
+from time_tracker._infrastructure import DB
+from time_tracker.customers import _domain as domain_customers
+from time_tracker.customers import _infrastructure as infrastructure_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,55 @@
+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"]
+
+
+# TODO: VALIDAR QUE NO EXISTA EL CLIENTE ANTES DE AGREGARLO
+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=customer_data["name"],
+            description=customer_data["description"],
+        )
+        created_customer = use_case.create_customer(customer_to_create)
+        if not created_customer:
+            return func.HttpResponse(
+                body=b'customer could not be created',
+                status_code=500,
+                mimetype="application/json"
+            )
+
+        return func.HttpResponse(
+            body=json.dumps(created_customer.__dict__),
+            status_code=201,
+            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/_persistence_contracts/_customers_dao.py

@@ -1,5 +1,5 @@
 import abc
-import typing
+# import typing
 
 from time_tracker.customers._domain import Customer
 

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

@@ -1,4 +1,4 @@
-import typing
+# import typing
 
 from time_tracker.customers._domain import Customer, CustomersDao
 

V2/time_tracker/customers/_infrastructure/_data_persistence/_customer_dao.py

@@ -1,6 +1,6 @@
 import dataclasses
 import sqlalchemy as sq
-import sqlalchemy.sql as sql
+# import sqlalchemy.sql as sql
 
 import time_tracker.customers._domain as domain
 from time_tracker._infrastructure import _db
@@ -27,7 +27,7 @@ def create(self, data: domain.Customer) -> domain.Customer:
             new_customer = data.__dict__
             new_customer.pop('id', None)
             new_customer['deleted'] = False
-            new_customer['status'] = 0
+            new_customer['status'] = 1
 
             query = self.customer.insert().values(new_customer).return_defaults()
             customer = self.db.get_session().execute(query)