feat: TT-418 crud and tests added

V2/serverless.yml

@@ -121,7 +121,7 @@ functions:
         x-azure-settings:
           methods:
             - POST
-          route: customer/
+          route: customers/
           authLevel: anonymous
 
   get_customers:
@@ -134,6 +134,16 @@ functions:
           route: customers/{id:?}
           authLevel: anonymous
 
+  update_customer:
+    handler: time_tracker/customers/interface.update_customer
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - PUT
+          route: customers/{id}
+          authLevel: anonymous
+
   delete_customer:
     handler: time_tracker/customers/interface.delete_customer
     events:
@@ -146,4 +156,5 @@ functions:
 
 #endregion Fin Customer
 
-#endregion Fin Funciones
+#endregion Fin Funciones
+

V2/tests/api/azure/customer_azure_endpoints_test.py

@@ -1,19 +1,14 @@
-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(
+def test__create_customer_azure_endpoint__creates_a_customer__when_customer_has_all_necesary_attributes(
     customer_factory
 ):
     customer_body = customer_factory().__dict__
@@ -33,7 +28,7 @@ def test__customer_azure_endpoint__creates_a_customer__when_customer_has_all_nec
     assert customer_json_data == customer_body
 
 
-def test__customer_azure_endpoint__returns_a_status_400__when_dont_recieve_all_necessary_attributes():
+def test__create_customer_azure_endpoint__returns_a_status_400__when_dont_recieve_all_necessary_attributes():
     customer_to_insert = {
         "id": None,
         "name": Faker().user_name(),
@@ -52,3 +47,117 @@ def test__customer_azure_endpoint__returns_a_status_400__when_dont_recieve_all_n
 
     assert response.status_code == 400
     assert response.get_body() == b'Invalid format or structure of the attributes of the customer'
+
+
+def test__delete_customer_azure_endpoint__returns_a_customer_with_true_deleted__when_its_id_is_found(
+    test_db, customer_factory, insert_customer
+):
+    customer_preinsert = customer_factory()
+    inserted_customer = insert_customer(customer_preinsert, test_db).__dict__
+
+    req = func.HttpRequest(
+        method='DELETE',
+        body=None,
+        url=CUSTOMER_URL,
+        route_params={"id": inserted_customer["id"]},
+    )
+
+    response = azure_customers._delete_customer.delete_customer(req)
+    customer_json_data = json.loads(response.get_body().decode("utf-8"))
+
+    assert response.status_code == 200
+    assert customer_json_data['deleted'] is True
+
+
+def test__update_customer_azure_endpoint__returns_an_updated_customer__when_customer_has_all_necesary_attributes(
+    test_db, customer_factory, insert_customer
+):
+    existent_customer = customer_factory()
+    inserted_customer = insert_customer(existent_customer, test_db).__dict__
+
+    inserted_customer["description"] = Faker().sentence()
+
+    body = json.dumps(inserted_customer).encode("utf-8")
+    req = func.HttpRequest(
+        method='PUT',
+        body=body,
+        url=CUSTOMER_URL,
+        route_params={"id": inserted_customer["id"]},
+    )
+
+    response = azure_customers._update_customer.update_customer(req)
+    customer_json_data = json.loads(response.get_body())
+
+    assert response.status_code == 200
+    assert customer_json_data == inserted_customer
+
+
+def test__update_customer_azure_endpoint__returns_update_a_customer__when_customer_has_all_necesary_attributes(
+    customer_factory
+):
+    existent_customer = customer_factory().__dict__
+
+    body = json.dumps(existent_customer).encode("utf-8")
+    req = func.HttpRequest(
+        method='PUT',
+        body=body,
+        url=CUSTOMER_URL,
+        route_params={"id": Faker().pyint()},
+    )
+
+    response = azure_customers._update_customer.update_customer(req)
+
+    assert response.status_code == 409
+    assert response.get_body() == b'This customer does not exist'
+
+
+def test__delete_customers_azure_endpoint__returns_a_status_code_400__when_customer_recive_invalid_id(
+):
+    req = func.HttpRequest(
+        method="DELETE",
+        body=None,
+        url=CUSTOMER_URL,
+        route_params={"id": "invalid id"},
+    )
+
+    response = azure_customers._delete_customer.delete_customer(req)
+
+    assert response.status_code == 400
+    assert response.get_body() == b'Invalid Format ID'
+
+
+def test__customers_azure_endpoint__returns_all_customers(
+    test_db, customer_factory, insert_customer
+):
+    customer_to_insert = customer_factory()
+
+    inserted_customer = insert_customer(customer_to_insert, test_db).__dict__
+
+    req = func.HttpRequest(method='GET', body=None, url=CUSTOMER_URL)
+    response = azure_customers._get_customers.get_customers(req)
+    customers_json_data = response.get_body().decode("utf-8")
+    customer_list = json.loads(customers_json_data)
+
+    assert response.status_code == 200
+    assert customers_json_data <= json.dumps(inserted_customer)
+    assert customer_list.pop() == inserted_customer
+
+
+def test__customer_azure_endpoint__returns_a_customer__when_customer_matches_its_id(
+    test_db, customer_factory, insert_customer
+):
+    existent_customer = customer_factory()
+    inserted_customer = insert_customer(existent_customer, test_db).__dict__
+
+    req = func.HttpRequest(
+        method='GET',
+        body=None,
+        url=CUSTOMER_URL,
+        route_params={"id": inserted_customer["id"]},
+    )
+
+    response = azure_customers._get_customers.get_customers(req)
+    customer_json_data = response.get_body().decode("utf-8")
+
+    assert response.status_code == 200
+    assert customer_json_data == json.dumps(inserted_customer)

V2/tests/conftest.py

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

V2/tests/fixtures.py

@@ -5,6 +5,7 @@
 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
+import time_tracker.customers._infrastructure as customer_infrastructure
 from time_tracker._infrastructure import DB
 
 
@@ -94,3 +95,12 @@ def _make_customer(
         return customer
 
     return _make_customer
+
+
+@pytest.fixture(name='insert_customer')
+def _insert_customer() -> dict:
+    def _new_customer(customer: customers_domain.Customer, database: DB):
+        dao = customer_infrastructure.CustomersSQLDao(database)
+        new_customer = dao.create(customer)
+        return new_customer
+    return _new_customer

V2/tests/integration/daos/customers_dao_test.py

@@ -1,4 +1,6 @@
 import pytest
+import typing
+from faker import Faker
 
 import time_tracker.customers._domain as domain
 import time_tracker.customers._infrastructure as infrastructure
@@ -22,7 +24,7 @@ def _clean_database():
     dao.db.get_session().execute(query)
 
 
-def test__customer_dao__returns_a_customer_dto__when_saves_correctly_with_sql_database(
+def test__create_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)
@@ -33,3 +35,104 @@ def test__customer_dao__returns_a_customer_dto__when_saves_correctly_with_sql_da
 
     assert isinstance(inserted_customer, domain.Customer)
     assert inserted_customer == customer_to_insert
+
+
+def test__get_all__returns_a_list_of_customer_dto_objects__when_one_or_more_customers_are_found_with_sql_database(
+    test_db, create_fake_dao, customer_factory, insert_customer
+):
+    dao = create_fake_dao(test_db)
+    customer_to_insert = customer_factory()
+    inserted_customer = [dao.create(customer_to_insert)]
+
+    customers = dao.get_all()
+
+    assert isinstance(customers, typing.List)
+    assert customers == inserted_customer
+
+
+def test_get_by_id__returns_a_customer_dto__when_found_one_customer_that_matches_its_id_with_sql_database(
+    test_db, create_fake_dao, customer_factory, insert_customer
+):
+    dao = create_fake_dao(test_db)
+    existent_customer = customer_factory()
+    inserted_customer = insert_customer(existent_customer, dao.db)
+
+    customer = dao.get_by_id(inserted_customer.id)
+
+    assert isinstance(customer, domain.Customer)
+    assert customer.id == inserted_customer.id
+    assert customer == inserted_customer
+
+
+def test__get_by_id__returns_none__when_no_customer_matches_its_id_with_sql_database(
+    test_db, create_fake_dao, customer_factory
+):
+    dao = create_fake_dao(test_db)
+    existent_customer = customer_factory()
+
+    customer = dao.get_by_id(existent_customer.id)
+
+    assert customer is None
+
+
+def test_get_all__returns_an_empty_list__when_doesnt_found_any_customers_with_sql_database(
+    test_db, create_fake_dao
+):
+    customers = create_fake_dao(test_db).get_all()
+
+    assert isinstance(customers, typing.List)
+    assert customers == []
+
+
+def test_delete__returns_a_customer_with_inactive_status__when_a_customer_matching_its_id_is_found_with_sql_database(
+    test_db, create_fake_dao, customer_factory, insert_customer
+):
+    dao = create_fake_dao(test_db)
+    existent_customer = customer_factory()
+    inserted_customer = insert_customer(existent_customer, dao.db)
+
+    customer = dao.delete(inserted_customer.id)
+
+    assert isinstance(customer, domain.Customer)
+    assert customer.id == inserted_customer.id
+    assert customer.status == 1
+    assert customer.deleted is True
+
+
+def test_delete__returns_none__when_no_customer_matching_its_id_is_found_with_sql_database(
+    test_db, create_fake_dao, customer_factory
+):
+    dao = create_fake_dao(test_db)
+    existent_customer = customer_factory()
+
+    results = dao.delete(existent_customer.id)
+
+    assert results is None
+
+
+def test__update_customer_dao__returns_an_updated_customer_dto__when_updates_correctly_with_sql_database(
+    test_db, customer_factory, create_fake_dao, insert_customer
+):
+    dao = create_fake_dao(test_db)
+
+    existent_customer = customer_factory()
+    inserted_customer = insert_customer(existent_customer, dao.db).__dict__
+
+    inserted_customer["description"] = Faker().sentence()
+
+    updated_customer = dao.update(inserted_customer["id"], domain.Customer(**inserted_customer))
+
+    assert isinstance(updated_customer, domain.Customer)
+    assert updated_customer.description == inserted_customer["description"]
+    assert updated_customer.__dict__ == inserted_customer
+
+
+def test__update_customer_dao__returns_None__when_an_incorrect_id_is_passed(
+    test_db, customer_factory, create_fake_dao, insert_customer
+):
+    dao = create_fake_dao(test_db)
+    existent_customer = customer_factory()
+
+    updated_customer = dao.update(Faker().pyint(), existent_customer)
+
+    assert updated_customer is None

V2/tests/unit/services/customer_service_test.py

@@ -1,3 +1,5 @@
+from faker import Faker
+
 from time_tracker.customers._domain import CustomerService
 
 
@@ -12,3 +14,57 @@ def test__create_customer__uses_the_customer_dao__to_create_a_customer(mocker, c
 
     assert customer_dao.create.called
     assert expected_customer == new_customer
+
+
+def test__delete_customer__uses_the_customer_dao__to_delete_customer_selected(
+    mocker,
+):
+    expected_customer = mocker.Mock()
+    customer_dao = mocker.Mock(
+        delete=mocker.Mock(return_value=expected_customer)
+    )
+
+    customer_service = CustomerService(customer_dao)
+    deleted_customer = customer_service.delete(Faker().pyint())
+
+    assert customer_dao.delete.called
+    assert expected_customer == deleted_customer
+
+
+def test__get_all__uses_the_customer_dao__to_retrieve_customers(mocker):
+    expected_customers = mocker.Mock()
+    customer_dao = mocker.Mock(
+        get_all=mocker.Mock(return_value=expected_customers)
+    )
+    customer_service = CustomerService(customer_dao)
+
+    actual_customers = customer_service.get_all()
+
+    assert customer_dao.get_all.called
+    assert expected_customers == actual_customers
+
+
+def test__get_by_id__uses_the_customer_dao__to_retrieve_one_customer(mocker):
+    expected_customer = mocker.Mock()
+    customer_dao = mocker.Mock(
+        get_by_id=mocker.Mock(return_value=expected_customer)
+    )
+    customer_service = CustomerService(customer_dao)
+
+    actual_customer = customer_service.get_by_id(Faker().pyint())
+
+    assert customer_dao.get_by_id.called
+    assert expected_customer == actual_customer
+
+
+def test__update_customer__uses_the_customer_dao__to_update_a_customer(mocker, customer_factory):
+    expected_customer = mocker.Mock()
+    customer_dao = mocker.Mock(
+        update=mocker.Mock(return_value=expected_customer)
+    )
+    customer_service = CustomerService(customer_dao)
+
+    updated_customer = customer_service.update(Faker().pyint(), customer_factory())
+
+    assert customer_dao.update.called
+    assert expected_customer == updated_customer