feat: TT-414 created get latest project, use case, service, dao

Author: ararcos

V2/serverless.yml

@@ -109,12 +109,13 @@ functions:
 
   get_latest_time_entry:
     handler: time_tracker/time_entries/interface.get_latest_entries
-     - http: true
+    events:
+      - http: true
         x-azure-settings:
           methods:
-            - GET
+            - GET   
           route: time-entries/latest
-          authLevel: anonymous
+          authLevel: anonymous   
 
   update_time_entry:
     handler: time_tracker/time_entries/interface.update_time_entry
@@ -186,4 +187,13 @@ functions:
           route: projects/
 
           authLevel: anonymous
-         
+
+  get_latest_projects:
+    handler: time_tracker/projects/interface.get_latest_projects
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - GET
+          route: projects/latest
+          authLevel: anonymous

V2/tests/api/azure/project_azure_endpoints_test.py

@@ -1,29 +1,14 @@
 import json
 from http import HTTPStatus
 
-import pytest
 from faker import Faker
 import azure.functions as func
 
 from time_tracker.projects._application import _projects as azure_projects
-from time_tracker.projects import _domain as domain
-from time_tracker.projects import _infrastructure as infrastructure
 
 PROJECT_URL = '/api/projects/'
 
 
-@pytest.fixture(name='insert_project')
-def _insert_project(test_db, insert_customer, project_factory, customer_factory) -> domain.Project:
-    inserted_customer = insert_customer(customer_factory(), test_db)
-
-    def _new_project():
-        project_to_insert = project_factory(customer_id=inserted_customer.id)
-        dao = infrastructure.ProjectsSQLDao(test_db)
-        inserted_project = dao.create(project_to_insert)
-        return inserted_project
-    return _new_project
-
-
 def test__project_azure_endpoint__returns_all_projects(
     insert_project
 ):
@@ -146,19 +131,17 @@ def test__update_project_azure_endpoint__returns_a_project__when_found_a_project
 
 
 def test__update_projects_azure_endpoint__returns_a_status_code_404__when_no_found_a_project_to_update(
-    project_factory
 ):
-    project_body = project_factory().__dict__
+    project_body = {"description": Faker().sentence()}
 
     req = func.HttpRequest(
         method="PUT",
         body=json.dumps(project_body).encode("utf-8"),
         url=PROJECT_URL,
-        route_params={"id": project_body["id"]},
+        route_params={"id": Faker().pyint()},
     )
 
     response = azure_projects._update_project.update_project(req)
-
     assert response.status_code == HTTPStatus.NOT_FOUND
     assert response.get_body() == b"Not found"
 

V2/tests/api/azure/time_entry_azure_endpoints_test.py

@@ -46,10 +46,11 @@ def test__time_entry_azure_endpoint__creates_an_time_entry__when_time_entry_has_
 
 
 def test__delete_time_entries_azure_endpoint__returns_an_time_entry_with_true_deleted__when_its_id_is_found(
-    test_db, time_entry_factory, insert_time_entry, insert_activity, activity_factory,
+    test_db, time_entry_factory, insert_time_entry, insert_activity, activity_factory, insert_project
 ):
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), test_db).__dict__
-    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"])
+    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], project_id=inserted_project.id)
     inserted_time_entry = insert_time_entry(time_entry_body, test_db)
 
     req = func.HttpRequest(
@@ -140,10 +141,11 @@ def test__get_time_entries_azure_endpoint__returns_a_status_code_400__when_time_
 
 
 def test__get_latest_entries_azure_endpoint__returns_a_list_of_latest_time_entries__when_an_owner_id_match(
-    test_db, time_entry_factory, insert_time_entry, insert_activity, activity_factory,
+    test_db, time_entry_factory, insert_time_entry, insert_activity, activity_factory, insert_project
 ):
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), test_db).__dict__
-    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], technologies="[jira,sql]")
+    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], project_id=inserted_project.id)
     inserted_time_entry = insert_time_entry(time_entry_body, test_db).__dict__
 
     req = func.HttpRequest(
@@ -179,27 +181,28 @@ def test__get_latest_entries_azure_endpoint__returns_no_time_entries_found__when
 
 
 def test__update_time_entry_azure_endpoint__returns_an_time_entry__when_found_an_time_entry_to_update(
-    test_db, time_entry_factory, insert_time_entry, activity_factory, insert_activity
+    test_db, time_entry_factory, insert_time_entry, activity_factory, insert_activity, insert_project
 ):
-    inserted_activity = insert_activity(activity_factory(), test_db)
-    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id)
-    inserted_time_entries = insert_time_entry(existent_time_entries, test_db).__dict__
+    inserted_project = insert_project()
+    inserted_activity = insert_activity(activity_factory(), test_db).__dict__
+    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], project_id=inserted_project.id)
+    inserted_time_entry = insert_time_entry(time_entry_body, test_db).__dict__
 
     time_entry_body = {"description": Faker().sentence()}
 
     req = func.HttpRequest(
         method='PUT',
         body=json.dumps(time_entry_body).encode("utf-8"),
         url=TIME_ENTRY_URL,
-        route_params={"id": inserted_time_entries["id"]},
+        route_params={"id": inserted_time_entry["id"]},
     )
 
     response = azure_time_entries._update_time_entry.update_time_entry(req)
     activitiy_json_data = response.get_body().decode("utf-8")
-    inserted_time_entries.update(time_entry_body)
+    inserted_time_entry.update(time_entry_body)
 
     assert response.status_code == 200
-    assert activitiy_json_data == json.dumps(inserted_time_entries)
+    assert activitiy_json_data == json.dumps(inserted_time_entry)
 
 
 def test__update_time_entries_azure_endpoint__returns_a_status_code_400__when_time_entry_recive_invalid_format_id():

V2/tests/conftest.py

@@ -2,4 +2,4 @@
 from fixtures import _activity_factory, _test_db, _insert_activity
 from fixtures import _time_entry_factory
 from fixtures import _customer_factory, _insert_customer
-from fixtures import _project_factory
+from fixtures import _project_factory, _insert_project

V2/tests/fixtures.py

@@ -7,6 +7,7 @@
 import time_tracker.customers._domain as customers_domain
 import time_tracker.customers._infrastructure as customers_infrastructure
 import time_tracker.projects._domain as projects_domain
+import time_tracker.projects._infrastructure as projects_infrastructure
 from time_tracker._infrastructure import DB
 
 
@@ -108,7 +109,8 @@ def _make_project(
         customer_id=Faker().pyint(),
         status=Faker().pyint(),
         deleted=False,
-        technologies=str(Faker().pylist())
+        technologies=str(Faker().pylist()),
+        customer=None
     ):
         project = projects_domain.Project(
             id=id,
@@ -118,7 +120,8 @@ def _make_project(
             customer_id=customer_id,
             status=status,
             deleted=deleted,
-            technologies=technologies
+            technologies=technologies,
+            customer=customer
             )
         return project
     return _make_project
@@ -131,3 +134,15 @@ def _new_customer(customer: customers_domain.Customer, database: DB):
         new_customer = dao.create(customer)
         return new_customer
     return _new_customer
+
+
+@pytest.fixture(name='insert_project')
+def _insert_project(test_db, insert_customer, project_factory, customer_factory) -> projects_domain.Project:
+    inserted_customer = insert_customer(customer_factory(), test_db)
+
+    def _new_project():
+        project_to_insert = project_factory(id=None, customer_id=inserted_customer.id, deleted=False)
+        dao = projects_infrastructure.ProjectsSQLDao(test_db)
+        inserted_project = dao.create(project_to_insert)
+        return inserted_project
+    return _new_project

V2/tests/integration/daos/projects_dao_test.py

@@ -7,18 +7,6 @@
 from time_tracker._infrastructure import DB
 
 
-@pytest.fixture(name='insert_project')
-def _insert_project(customer_factory, test_db, insert_customer, create_fake_dao, project_factory) -> domain.Project:
-    inserted_customer = insert_customer(customer_factory(), test_db)
-
-    def _new_project():
-        project_to_insert = project_factory(customer_id=inserted_customer.id)
-        inserted_project = create_fake_dao.create(project_to_insert)
-        return inserted_project
-
-    return _new_project
-
-
 @pytest.fixture(name='create_fake_dao')
 def _create_fake_dao() -> domain.ProjectsDao:
     db_fake = DB()
@@ -44,6 +32,9 @@ def test__create_project__returns_a_project_dto__when_saves_correctly_with_sql_d
 
     inserted_project = dao.create(project_to_insert)
 
+    expected_project = project_to_insert.__dict__
+    expected_project.update({"customer": inserted_customer.__dict__})
+
     assert isinstance(inserted_project, domain.Project)
     assert inserted_project == project_to_insert
 
@@ -85,6 +76,7 @@ def test__get_all__returns_a_list_of_project_dto_objects__when_one_or_more_proje
     ]
 
     projects = dao.get_all()
+
     assert isinstance(projects, typing.List)
     assert projects == inserted_projects
 

V2/tests/integration/daos/time_entries_dao_test.py

@@ -26,12 +26,12 @@ def _clean_database():
 
 
 def test__time_entry__returns_a_time_entry_dto__when_saves_correctly_with_sql_database(
-    test_db, time_entry_factory, create_fake_dao, insert_activity, activity_factory
+    test_db, time_entry_factory, create_fake_dao, insert_activity, activity_factory, insert_project
 ):
     dao = create_fake_dao(test_db)
     inserted_activity = insert_activity(activity_factory(), dao.db)
-
-    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id)
+    inserted_project = insert_project()
+    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id, project_id=inserted_project.id)
 
     inserted_time_entry = dao.create(time_entry_to_insert)
 
@@ -51,12 +51,13 @@ def test__time_entry__returns_None__when_not_saves_correctly(
 
 
 def test_delete__returns_an_time_entry_with_true_deleted__when_an_time_entry_matching_its_id_is_found(
-    create_fake_dao, test_db, time_entry_factory, insert_activity, activity_factory
+    create_fake_dao, test_db, time_entry_factory, insert_activity, activity_factory, insert_project
 ):
     dao = create_fake_dao(test_db)
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), dao.db)
-    existent_time_entry = time_entry_factory(activity_id=inserted_activity.id)
-    inserted_time_entry = dao.create(existent_time_entry)
+    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id, project_id=inserted_project.id)
+    inserted_time_entry = dao.create(time_entry_to_insert)
 
     result = dao.delete(inserted_time_entry.id)
 
@@ -74,18 +75,17 @@ def test_delete__returns_none__when_no_time_entry_matching_its_id_is_found(
 
 
 def test_get_latest_entries__returns_a_list_of_latest_time_entries__when_an_owner_id_match(
-    create_fake_dao, time_entry_factory, insert_activity, activity_factory, test_db
+    create_fake_dao, time_entry_factory, insert_activity, activity_factory, test_db, insert_project
 ):
     dao = create_fake_dao(test_db)
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), dao.db)
-    time_entry_to_insert = time_entry_factory(
-        activity_id=inserted_activity.id,
-        technologies="[jira,sql]")
-    inserted_time_entry = dao.create(time_entry_to_insert)
+    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id, project_id=inserted_project.id)
+    inserted_time_entry = dao.create(time_entry_to_insert).__dict__
 
-    result = dao.get_latest_entries(int(inserted_time_entry.owner_id))
+    result = dao.get_latest_entries(int(inserted_time_entry["owner_id"]))
 
-    assert result == [inserted_time_entry.__dict__]
+    assert result == [inserted_time_entry]
 
 
 def test_get_latest_entries__returns_none__when_an_owner_id_is_not_found(
@@ -100,30 +100,33 @@ def test_get_latest_entries__returns_none__when_an_owner_id_is_not_found(
 
 
 def test_update__returns_an_time_entry_dto__when_found_one_time_entry_to_update(
-    test_db, create_fake_dao, time_entry_factory, insert_activity, activity_factory
+    test_db, create_fake_dao, time_entry_factory, insert_activity, activity_factory, insert_project
 ):
     dao = create_fake_dao(test_db)
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), dao.db)
-    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id)
-    inserted_time_entries = dao.create(existent_time_entries).__dict__
-    time_entry_id = inserted_time_entries["id"]
-    inserted_time_entries.update({"description": "description updated"})
+    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id, project_id=inserted_project.id)
+    inserted_time_entry = dao.create(time_entry_to_insert).__dict__
+
+    time_entry_id = inserted_time_entry["id"]
+    inserted_time_entry.update({"description": "description updated"})
 
-    time_entry = dao.update(time_entry_id=time_entry_id, time_entry_data=inserted_time_entries)
+    time_entry = dao.update(time_entry_id=time_entry_id, time_entry_data=inserted_time_entry)
 
     assert time_entry.id == time_entry_id
-    assert time_entry.description == inserted_time_entries.get("description")
+    assert time_entry.description == inserted_time_entry.get("description")
 
 
 def test_update__returns_none__when_doesnt_found_one_time_entry_to_update(
-    test_db, create_fake_dao, time_entry_factory, insert_activity, activity_factory
+    test_db, create_fake_dao, time_entry_factory, insert_activity, activity_factory, insert_project
 ):
     dao = create_fake_dao(test_db)
+    inserted_project = insert_project()
     inserted_activity = insert_activity(activity_factory(), dao.db)
-    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id)
-    inserted_time_entries = dao.create(existent_time_entries).__dict__
+    time_entry_to_insert = time_entry_factory(activity_id=inserted_activity.id, project_id=inserted_project.id)
+    inserted_time_entry = dao.create(time_entry_to_insert).__dict__
 
-    time_entry = dao.update(0, inserted_time_entries)
+    time_entry = dao.update(0, inserted_time_entry)
 
     assert time_entry is None
 

V2/time_tracker/projects/_application/__init__.py

@@ -2,4 +2,5 @@
 from ._projects import create_project
 from ._projects import delete_project
 from ._projects import get_projects
-from ._projects import update_project
+from ._projects import update_project
+from ._projects import get_latest_projects

V2/time_tracker/projects/_application/_projects/__init__.py

@@ -2,4 +2,5 @@
 from ._create_project import create_project
 from ._delete_project import delete_project
 from ._get_projects import get_projects
-from ._update_project import update_project
+from ._update_project import update_project
+from ._get_latest_projects import get_latest_projects

V2/time_tracker/projects/_application/_projects/_create_project.py

@@ -31,7 +31,8 @@ def create_project(req: func.HttpRequest) -> func.HttpResponse:
           customer_id=project_data["customer_id"],
           status=project_data["status"],
           deleted=False,
-          technologies=project_data["technologies"]
+          technologies=project_data["technologies"],
+          customer=None
         )
 
         created_project = use_case.create_project(project_to_create)