test: TT-404 get time entries

Author: Jobzi

V2/create_activity/function.json

@@ -1,4 +1,4 @@
 # flake8: noqa
-from fixtures import _activity_factory, _create_fake_dao, _create_fake_database
-from tests.api.api_fixtures import create_temp_activities
+from fixtures import _activity_factory, _create_fake_database, _time_entry_factory,_insert_activity
+#from tests.api.api_fixtures import create_temp_activities
 from tests.api.api_fixtures import create_temp_time_entries

V2/delete_activity/function.json

@@ -1,17 +1,18 @@
 import pytest
+from faker import Faker
 
-import time_tracker.activities._domain as domain
-import time_tracker.activities._infrastructure as infrastructure
+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
-from faker import Faker
 
 
 @pytest.fixture(name='activity_factory')
-def _activity_factory() -> 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 = domain.Activity(
+        activity = domain_activities.Activity(
             id=None,
             name=name,
             description=description,
@@ -22,14 +23,47 @@ def _make_activity(
     return _make_activity
 
 
-@pytest.fixture(name='create_fake_dao')
-def _create_fake_dao() -> domain.ActivitiesDao:
-    db_fake = DB('sqlite:///:memory:')
-    dao = infrastructure.ActivitiesSQLDao(db_fake)
-    return dao
-
-
 @pytest.fixture(name='create_fake_database')
-def _create_fake_database() -> domain.ActivitiesDao:
+def _create_fake_database() -> DB:
     db_fake = DB('sqlite:///:memory:')
     return db_fake
+
+
+@pytest.fixture(name='time_entry_factory')
+def _time_entry_factory() -> domain_time_entries.TimeEntry:
+    def _make_time_entry(
+        id=Faker().random_int(),
+        start_date=str(Faker().date_time()),
+        owner_id=Faker().random_int(),
+        description=Faker().sentence(),
+        activity_id=Faker().random_int(),
+        uri=Faker().domain_name(),
+        technologies=["jira", "git"],
+        end_date=str(Faker().date_time()),
+        deleted=False,
+        timezone_offset="300",
+        project_id=Faker().random_int(),
+    ):
+        time_entry = domain_time_entries.TimeEntry(
+            id=id,
+            start_date=start_date,
+            owner_id=owner_id,
+            description=description,
+            activity_id=activity_id,
+            uri=uri,
+            technologies=technologies,
+            end_date=end_date,
+            deleted=deleted,
+            timezone_offset=timezone_offset,
+            project_id=project_id,
+            )
+        return time_entry
+    return _make_time_entry
+    
+@pytest.fixture(name='insert_activity')
+def _insert_activity() -> dict:
+    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/get_activities/function.json

@@ -1,11 +1,17 @@
-from time_tracker.time_entries._infrastructure import TimeEntriesJsonDao
-from time_tracker.time_entries._domain import TimeEntry
-from faker import Faker
 import json
 import pytest
 import typing
 import random
 
+from faker import Faker
+
+import time_tracker.activities._domain as domain
+import time_tracker.activities._infrastructure as infrastructure
+from time_tracker._infrastructure import DB
+
+from time_tracker.time_entries._infrastructure import TimeEntriesSQLDao 
+from time_tracker.time_entries._domain import TimeEntry,TimeEntriesDao
+
 fake_time_entries = [
     {
         "id": Faker().pyint(),
@@ -21,60 +27,142 @@
         "project_id": Faker().uuid4(),
     }
 ]
+# @pytest.fixture(name='insert_activity')
+# def _insert_activity() -> domain.Activity:
+#     def _new_activity(activity: domain.Activity, dao: domain.ActivitiesDao):
+#         new_activity = dao.create(activity)
+#         return new_activity
+#     return _new_activity
 
 
-@pytest.fixture(name="create_fake_time_entries")
-def _create_fake_time_entries(mocker) -> typing.List[TimeEntry]:
-    def _creator(time_entries):
-        read_data = json.dumps(time_entries)
-        mocker.patch("builtins.open", mocker.mock_open(read_data=read_data))
-        return [TimeEntry(**time_entry) for time_entry in time_entries]
 
-    return _creator
+@pytest.fixture(name='insert_time_entry')
+def _insert_time_entry() -> TimeEntry:
+    def _new_time_entry(time_entry: TimeEntry, dao: TimeEntriesSQLDao):
+        _new_time_entry = dao.create(time_entry)
+        return _new_time_entry
+    return _new_time_entry
 
+@pytest.fixture(name='create_fake_dao')
+def _create_fake_dao() -> TimeEntriesSQLDao:
+    db_fake = DB('sqlite:///:memory:')
+    dao = TimeEntriesSQLDao(db_fake)
+    return dao
 
-def test_get_by_id__returns_an_time_entry_dto__when_found_one_time_entry_that_matches_its_id(
-    create_fake_time_entries,
-):
-    print(fake_time_entries)
-    time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
-    time_entries = create_fake_time_entries(fake_time_entries)
-    time_entries_dto = time_entries.pop()
 
-    result = time_entries_json_dao.get_by_id(time_entries_dto.id)
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB('sqlite:///:memory:')
+    dao = infrastructure.ActivitiesSQLDao(db_fake)
+    query = dao.activity.delete()
+    dao.db.get_session().execute(query)
+
 
-    assert result == time_entries_dto
 
+# @pytest.fixture(name="create_fake_time_entries")
+# def _create_fake_time_entries(mocker) -> typing.List[TimeEntry]:
+#     def _creator(time_entries):
+#         read_data = json.dumps(time_entries)
+#         mocker.patch("builtins.open", mocker.mock_open(read_data=read_data))
+#         return [TimeEntry(**time_entry) for time_entry in time_entries]
 
-def test__get_by_id__returns_none__when_no_time_entry_matches_its_id(
-    create_fake_time_entries,
+#     return _creator
+
+
+def test__get_all__returns_a_list_of_time_entries_dto_objects__when_one_or_more_time_entries_are_found_in_sql_database(
+    create_fake_dao, time_entry_factory, insert_time_entry,insert_activity, activity_factory
 ):
-    time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
-    create_fake_time_entries([])
+    dao=create_fake_dao
+    inserted_activity = insert_activity(activity_factory(),dao.db)
+    print("================")
+    print(activity_factory())
+    print(inserted_activity)
+    existent_time_entries = [time_entry_factory(activity_id=inserted_activity.id)]
+    inserted_time_entries = [insert_time_entry(existent_time_entries[0], dao)]
+    time_entry= dao.get_all()
+   
+    assert isinstance(time_entry, typing.List)
+    assert time_entry == inserted_time_entries
 
-    result = time_entries_json_dao.get_by_id(Faker().uuid4())
+# def test__get_by_id__returns_none__when_no_time_entry_matches_its_id(
+#     create_fake_time_entries,
+# ):
+#     time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
+#     create_fake_time_entries([])
 
-    assert result is None
+#     result = time_entries_json_dao.get_by_id(Faker().uuid4())
 
+#     assert result is None
 
-def test__get_all__returns_a_list_of_time_entry_dto_objects__when_one_or_more_time_entries_are_found(
-    create_fake_time_entries,
-):
-    time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
-    number_of_time_entries = 3
-    time_entries = create_fake_time_entries(fake_time_entries * number_of_time_entries)
 
-    result = time_entries_json_dao.get_all()
+# def test__get_all__returns_a_list_of_time_entry_dto_objects__when_one_or_more_time_entries_are_found(
+#     create_fake_time_entries,
+# ):
+#     time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
+#     number_of_time_entries = 3
+#     time_entries = create_fake_time_entries(fake_time_entries * number_of_time_entries)
 
-    assert result == time_entries
+#     result = time_entries_json_dao.get_all()
 
+#     assert result == time_entries
+
+
+# def test_get_all__returns_an_empty_list__when_doesnt_found_any_time_entries(
+#     create_fake_time_entries,
+# ):
+#     time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
+#     time_entries = create_fake_time_entries([])
+
+#     result = time_entries_json_dao.get_all()
+
+#     assert result == time_entries
+
+# def test__get_all__returns_a_list_of_activity_dto_objects__when_one_or_more_activities_are_found_with_sql_database(
+#     create_fake_dao, activity_factory, insert_activity
+# ):
+#     dao = create_fake_dao
+#     existent_activities = [activity_factory(), activity_factory()]
+#     inserted_activities = [
+#         insert_activity(existent_activities[0], dao),
+#         insert_activity(existent_activities[1], dao)
+#     ]
+
+#     activities = dao.get_all()
+
+#     assert isinstance(activities, typing.List)
+#     assert activities == inserted_activities
+
+
+# def test_get_by_id__returns_an_activity_dto__when_found_one_activity_that_matches_its_id_with_sql_database(
+#     create_fake_dao, activity_factory, insert_activity
+# ):
+#     dao = create_fake_dao
+#     existent_activity = activity_factory()
+#     inserted_activity = insert_activity(existent_activity, dao)
+
+#     activity = dao.get_by_id(inserted_activity.id)
+
+#     assert isinstance(activity, domain.Activity)
+#     assert activity.id == inserted_activity.id
+#     assert activity == inserted_activity
+
+
+# def test__get_by_id__returns_none__when_no_activity_matches_its_id_with_sql_database(
+#     create_fake_dao, activity_factory
+# ):
+#     dao = create_fake_dao
+#     existent_activity = activity_factory()
+
+#     activity = dao.get_by_id(existent_activity.id)
+
+#     assert activity is None
 
-def test_get_all__returns_an_empty_list__when_doesnt_found_any_time_entries(
-    create_fake_time_entries,
-):
-    time_entries_json_dao = TimeEntriesJsonDao(Faker().file_path())
-    time_entries = create_fake_time_entries([])
 
-    result = time_entries_json_dao.get_all()
+# def test_get_all__returns_an_empty_list__when_doesnt_found_any_activities_with_sql_database(
+#     create_fake_dao
+# ):
+#     activities = create_fake_dao.get_all()
 
-    assert result == time_entries
+#     assert isinstance(activities, typing.List)
+#     assert activities == []

V2/tests/conftest.py

@@ -41,7 +41,7 @@ def get_all(self) -> typing.List[domain.Activity]:
 
     def create(self, activity_data: domain.Activity) -> domain.Activity:
         new_activity = activity_data.__dict__
-        new_activity.pop('id', None)
+        #new_activity.pop('id', None)
         new_activity.update({"status": 1, "deleted": False})
 
         query = self.activity.insert().values(new_activity).return_defaults()