Merge branch 'TT-418-CRUD-CUSTOMER-V2' of https://github.com/ioet/time-tracker-backend into TT-418-CRUD-CUSTOMER-V2

Author: gcobena-dev

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,4 +1,4 @@
 # flake8: noqa
 from ._customers import create_customer
 from ._customers import get_customers
-from ._customers import delete_customer
+from ._customers import delete_customer

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

@@ -1,4 +1,2 @@
 # flake8: noqa
-from ._create_customer import create_customer
-from ._get_customers import get_customers
-from ._delete_customer import delete_customer
+from ._create_customer import create_customer

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

@@ -0,0 +1,36 @@
+import json
+
+import azure.functions as func
+
+from ... import _domain
+from ... import _infrastructure
+from time_tracker._infrastructure import DB
+
+
+def delete_time_entry(req: func.HttpRequest) -> func.HttpResponse:
+    time_entry_dao = _infrastructure.TimeEntriesSQLDao(DB())
+    time_entry_service = _domain.TimeEntryService(time_entry_dao)
+    use_case = _domain._use_cases.DeleteTimeEntryUseCase(time_entry_service)
+
+    try:
+        time_entry_id = int(req.route_params.get("id"))
+        deleted_time_entry = use_case.delete_time_entry(time_entry_id)
+        if not deleted_time_entry:
+            return func.HttpResponse(
+                body="Not found",
+                status_code=404,
+                mimetype="application/json"
+            )
+
+        return func.HttpResponse(
+            body=json.dumps(deleted_time_entry.__dict__, default=str),
+            status_code=200,
+            mimetype="application/json",
+        )
+
+    except ValueError:
+        return func.HttpResponse(
+            body=b"Invalid Format ID",
+            status_code=400,
+            mimetype="application/json"
+        )

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