feat: TT-404 get time entries

Author: scastillo-jp

V2/serverless.yml

@@ -63,9 +63,9 @@ functions:
       - http: true
         x-azure-settings:
           methods:
-            - PUT   
+            - PUT
           route: activities/{id}
-          authLevel: anonymous    
+          authLevel: anonymous
 
   create_activity:
     handler: time_tracker/activities/interface.create_activity
@@ -87,6 +87,16 @@ functions:
           route: time-entries/
           authLevel: anonymous
 
+  get_time_entries:
+    handler: time_tracker/time_entries/interface.get_time_entries
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - GET
+          route: time_entries/{id:?}
+          authLevel: anonymous
+
   delete_time_entry:
     handler: time_tracker/time_entries/interface.delete_time_entry
     events:

V2/tests/api/azure/time_entry_azure_endpoints_test.py

@@ -1,5 +1,6 @@
 import pytest
 import json
+import pytest
 
 import azure.functions as func
 
@@ -9,7 +10,7 @@
 from time_tracker.time_entries import _infrastructure as infrastructure_time_entries
 
 
-TIME_ENTRY_URL = "/api/time-entries/"
+TIME_ENTRY_URL = "/api/time_entries/"
 
 
 @pytest.fixture(name='insert_time_entry')
@@ -76,3 +77,65 @@ def test__delete_time_entries_azure_endpoint__returns_a_status_code_400__when_ti
 
     assert response.status_code == 400
     assert response.get_body() == b'Invalid Format ID'
+
+
+def test__time_entry_azure_endpoint__returns_all_time_entries(
+     create_fake_database, time_entry_factory, insert_time_entry, activity_factory, insert_activity
+):
+    fake_database = create_fake_database
+    inserted_activity = insert_activity(activity_factory(), fake_database)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    inserted_time_entries = [insert_time_entry(existent_time_entries, fake_database)]
+
+    azure_time_entries._get_time_entries.DATABASE = fake_database
+    req = func.HttpRequest(method="GET", body=None, url=TIME_ENTRY_URL)
+
+    response = azure_time_entries.get_time_entries(req)
+    time_entries_json_data = response.get_body().decode("utf-8")
+
+    assert response.status_code == 200
+    assert time_entries_json_data == json.dumps(inserted_time_entries)
+
+
+def test__time_entry_azure_endpoint__returns_an_time_entry__when_time_entry_matches_its_id(
+     create_fake_database, time_entry_factory, insert_time_entry, activity_factory, insert_activity
+):
+    fake_database = create_fake_database
+    inserted_activity = insert_activity(activity_factory(), fake_database)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    inserted_time_entries = insert_time_entry(existent_time_entries, fake_database)
+
+    azure_time_entries._get_time_entries.DATABASE = fake_database
+
+    req = func.HttpRequest(
+        method="GET",
+        body=None,
+        url=TIME_ENTRY_URL,
+        route_params={"id": inserted_time_entries["id"]},
+    )
+
+    response = azure_time_entries.get_time_entries(req)
+    time_entry_json_data = response.get_body().decode("utf-8")
+
+    assert response.status_code == 200
+    assert time_entry_json_data == json.dumps(inserted_time_entries)
+
+
+def test__get_time_entries_azure_endpoint__returns_a_status_code_400__when_time_entry_recive_invalid_id(
+    test_db, time_entry_factory, insert_time_entry, activity_factory, insert_activity
+):
+    inserted_activity = insert_activity(activity_factory(), test_db)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    insert_time_entry(existent_time_entries, test_db)
+
+    req = func.HttpRequest(
+        method="GET",
+        body=None,
+        url=TIME_ENTRY_URL,
+        route_params={"id": "invalid id"},
+    )
+
+    response = azure_time_entries.get_time_entries(req)
+
+    assert response.status_code == 400
+    assert response.get_body() == b'Invalid Format ID'

V2/tests/conftest.py

@@ -1,3 +1,2 @@
 # flake8: noqa
-from fixtures import _activity_factory, _test_db, _insert_activity
-from fixtures import _time_entry_factory
+from fixtures import _activity_factory, _test_db, _create_fake_database, _create_fake_dao, _time_entry_factory,_insert_activity

V2/tests/fixtures.py

@@ -1,21 +1,21 @@
 import pytest
 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.activities._domain as domain_activities
+import time_tracker.activities._infrastructure as infrastructure_activities
+import time_tracker.time_entries._domain as domain_time_entries
 from time_tracker._infrastructure import DB
 
 
 @pytest.fixture(name='activity_factory')
-def _activity_factory() -> activities_domain.Activity:
+def _activity_factory() -> domain_activities.Activity:
     def _make_activity(
         name: str = Faker().name(),
         description: str = Faker().sentence(),
         deleted: bool = False,
         status: int = 1,
     ):
-        activity = activities_domain.Activity(
+        activity = domain_activities.Activity(
             id=None,
             name=name,
             description=description,
@@ -33,9 +33,21 @@ def _test_db() -> DB:
     db_fake.get_session().execute("pragma foreign_keys=ON")
     return db_fake
 
+@pytest.fixture(name='create_fake_dao')
+def _create_fake_dao() -> domain_activities.ActivitiesDao:
+    db_fake = DB('sqlite:///:memory:')
+    dao = infrastructure_activities.ActivitiesSQLDao(db_fake)
+    return dao
+
+
+@pytest.fixture(name='create_fake_database')
+def _create_fake_database() -> DB:
+    db_fake = DB('sqlite:///:memory:')
+    return db_fake
+
 
 @pytest.fixture(name='time_entry_factory')
-def _time_entry_factory() -> time_entries_domain.TimeEntry:
+def _time_entry_factory() -> domain_time_entries.TimeEntry:
     def _make_time_entry(
         id=Faker().random_int(),
         start_date=str(Faker().date_time()),
@@ -49,7 +61,7 @@ def _make_time_entry(
         timezone_offset="300",
         project_id=Faker().random_int(),
     ):
-        time_entry = time_entries_domain.TimeEntry(
+        time_entry = domain_time_entries.TimeEntry(
             id=id,
             start_date=start_date,
             owner_id=owner_id,
@@ -68,8 +80,8 @@ def _make_time_entry(
 
 @pytest.fixture(name='insert_activity')
 def _insert_activity() -> dict:
-    def _new_activity(activity: activities_domain.Activity, database: DB):
-        dao = activities_infrastructure.ActivitiesSQLDao(database)
+    def _new_activity(activity: domain_activities.Activity, database: DB):
+        dao = infrastructure_activities.ActivitiesSQLDao(database)
         new_activity = dao.create(activity)
         return new_activity
     return _new_activity

V2/tests/integration/daos/time_entries_json_dao_test.py

@@ -0,0 +1,80 @@
+import pytest
+import typing
+
+from faker import Faker
+
+import time_tracker.activities._infrastructure as infrastructure_activities
+
+from time_tracker.time_entries._infrastructure import TimeEntriesSQLDao
+from time_tracker.time_entries._domain import TimeEntry
+
+from time_tracker._infrastructure import DB
+
+
+@pytest.fixture(name='create_time_enty_fake_dao')
+def _create_fake_dao() -> TimeEntriesSQLDao:
+    db_fake = DB('sqlite:///:memory:')
+    dao = TimeEntriesSQLDao(db_fake)
+    return dao
+
+
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB('sqlite:///:memory:')
+    dao = infrastructure_activities.ActivitiesSQLDao(db_fake)
+    query = dao.activity.delete()
+    dao.db.get_session().execute(query)
+
+
+def test__get_all__returns_a_list_of_time_entries_dto_objects__when_one_or_more_time_entries_are_found_in_sql_database(
+    create_time_enty_fake_dao, time_entry_factory, insert_activity, activity_factory
+):
+
+    dao = create_time_enty_fake_dao
+    inserted_activity = insert_activity(activity_factory(), dao.db)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    inserted_time_entries = [dao.create(existent_time_entries)]
+
+    time_entry = dao.get_all()
+
+    assert isinstance(time_entry, typing.List)
+    assert time_entry == inserted_time_entries
+
+
+def test__get_all__returns_an_empty_list__when_doesnt_found_any_time_entries_in_sql_database(
+    create_time_enty_fake_dao, insert_activity, activity_factory
+):
+    dao = create_time_enty_fake_dao
+    insert_activity(activity_factory(), dao.db)
+
+    time_entry = dao.get_all()
+    assert time_entry == []
+
+
+def test__get_by_id__returns_a_time_entry_dto__when_found_one_time_entry_that_match_id_with_sql_database(
+    create_time_enty_fake_dao, time_entry_factory, insert_activity, activity_factory
+):
+    dao = create_time_enty_fake_dao
+    inserted_activity = insert_activity(activity_factory(), dao.db)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    inserted_time_entries = dao.create(existent_time_entries)
+
+    time_entry = dao.get_by_id(existent_time_entries.id)
+
+    assert isinstance(time_entry, TimeEntry)
+    assert time_entry.id == inserted_time_entries.id
+    assert time_entry == inserted_time_entries
+
+
+def test__get_by_id__returns_none__when_no_time_entry_matches_by_id(
+    create_time_enty_fake_dao, time_entry_factory, insert_activity, activity_factory
+):
+    dao = create_time_enty_fake_dao
+    inserted_activity = insert_activity(activity_factory(), dao.db)
+    existent_time_entries = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+    dao.create(existent_time_entries)
+
+    time_entry = dao.get_by_id(Faker().pyint())
+
+    assert time_entry is None

V2/tests/unit/services/time_entry_service_test.py

@@ -29,3 +29,29 @@ def test__delete_time_entry__uses_the_time_entry_dao__to_delete_time_entry_selec
 
     assert time_entry_dao.delete.called
     assert expected_time_entry == deleted_time_entry
+
+
+def test__get_all__uses_the_time_entry_dao__to_retrieve_time_entries(mocker):
+    expected_time_entries = mocker.Mock()
+    time_entry_dao = mocker.Mock(
+        get_all=mocker.Mock(return_value=expected_time_entries)
+    )
+    time_activity_service = TimeEntryService(time_entry_dao)
+
+    actual_activities = time_activity_service.get_all()
+
+    assert time_entry_dao.get_all.called
+    assert expected_time_entries == actual_activities
+
+
+def test__get_by_id__uses_the_time_entry_dao__to_retrieve_one_time_entry(mocker):
+    expected_time_entry = mocker.Mock()
+    time_entry_dao = mocker.Mock(
+        get_by_id=mocker.Mock(return_value=expected_time_entry)
+    )
+    time_entry_service = TimeEntryService(time_entry_dao)
+
+    actual_time_entry = time_entry_service.get_by_id(Faker().uuid4())
+
+    assert time_entry_dao.get_by_id.called
+    assert expected_time_entry == actual_time_entry

V2/tests/unit/use_cases/time_entries_use_case_test.py

@@ -3,6 +3,8 @@
 
 from time_tracker.time_entries._domain import _use_cases
 
+fake = Faker()
+
 
 def test__create_time_entry_function__uses_the_time_entries_service__to_create_time_entry(
     mocker: MockFixture, time_entry_factory
@@ -30,3 +32,33 @@ def test__delete_time_entry_function__uses_the_time_entry_service__to_delete_tim
 
     assert time_entry_service.delete.called
     assert expected_time_entry == deleted_time_entry
+
+
+def test__get_list_time_entries_function__uses_the_time_entry_service__to_retrieve_time_entries(
+    mocker: MockFixture,
+):
+    expected_time_entries = mocker.Mock()
+    time_entry_service = mocker.Mock(
+        get_all=mocker.Mock(return_value=expected_time_entries)
+    )
+
+    time_entries_use_case = _use_cases.GetTimeEntriesUseCase(time_entry_service)
+    actual_time_entries = time_entries_use_case.get_time_entries()
+
+    assert time_entry_service.get_all.called
+    assert expected_time_entries == actual_time_entries
+
+
+def test__get_time_entry_by_id_function__uses_the_time_entry_service__to_retrieve_time_entry(
+    mocker: MockFixture,
+):
+    expected_time_entries = mocker.Mock()
+    time_entry_service = mocker.Mock(
+        get_by_id=mocker.Mock(return_value=expected_time_entries)
+    )
+
+    time_entry_use_case = _use_cases.GetTimeEntryUseCase(time_entry_service)
+    actual_time_entry = time_entry_use_case.get_time_entry_by_id(fake.uuid4())
+
+    assert time_entry_service.get_by_id.called
+    assert expected_time_entries == actual_time_entry

V2/time_tracker/_infrastructure/_db.py

@@ -2,6 +2,8 @@
 
 from . import _config
 
+_TEST_DIALECT = "sqlite"
+
 
 class DB():
     config = _config.load_config()
@@ -17,4 +19,6 @@ def get_session(self):
         self.metadata.create_all(self.engine)
         if self.connection is None:
             self.connection = self.engine.connect()
+            if self.engine.dialect.name == _TEST_DIALECT:
+                self.connection.execute("pragma foreign_keys=ON")
         return self.connection

V2/time_tracker/time_entries/_application/__init__.py

@@ -1,2 +1,4 @@
 # flake8: noqa
-from ._time_entries import create_time_entry, delete_time_entry
+from ._time_entries import create_time_entry
+from ._time_entries import delete_time_entry
+from ._time_entries import get_time_entries

V2/time_tracker/time_entries/_application/_time_entries/__init__.py

@@ -1,3 +1,4 @@
 # flake8: noqa
 from ._create_time_entry import create_time_entry
-from ._delete_time_entry import delete_time_entry
+from ._delete_time_entry import delete_time_entry
+from ._get_time_entries import get_time_entries