fix: implementation of the database connection

Author: ararcos

V2/create_activity/function.json

@@ -1,27 +1,43 @@
+import pytest
 import json
 
 import azure.functions as func
 
-from time_tracker.time_entries._application import _time_entries as time_entries
+import time_tracker.time_entries._application._time_entries as azure_time_entries
+from time_tracker._infrastructure import DB
+from time_tracker.activities import _domain as domain_activities
+from time_tracker.activities import _infrastructure as infrastructure_activities
 
 TIME_ENTRY_URL = "/api/time-entries/"
 
 
+@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.__dict__
+    return _new_activity
+
+
 def test__time_entry_azure_endpoint__creates_an_time_entry__when_time_entry_has_all_attributes(
-    create_temp_time_entries, time_entry_factory
+    create_fake_database, time_entry_factory, activity_factory, insert_activity
 ):
-    time_entries_json, tmp_directory = create_temp_time_entries
-    time_entries._create_time_entry._JSON_PATH = tmp_directory
+    db = create_fake_database
+    inserted_activity = insert_activity(activity_factory(), db)
+    time_entry_body = time_entry_factory(activity_id=inserted_activity["id"], technologies="[jira,sql]").__dict__
 
-    time_entry_body = time_entry_factory(None).__dict__
+    azure_time_entries._create_time_entry._DATABASE = db
     body = json.dumps(time_entry_body).encode("utf-8")
     req = func.HttpRequest(
-        method="POST",
-        body=body,
-        url=TIME_ENTRY_URL,
+         method='POST',
+         body=body,
+         url=TIME_ENTRY_URL,
     )
 
-    response = time_entries.create_time_entry(req)
-    time_entry_json_data = response.get_body()
+    response = azure_time_entries._create_time_entry.create_time_entry(req)
+    time_entry_json_data = json.loads(response.get_body())
+    time_entry_body['id'] = time_entry_json_data['id']
+
     assert response.status_code == 201
-    assert time_entry_json_data == body
+    assert time_entry_json_data == time_entry_body

V2/delete_activity/function.json

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

V2/get_activities/function.json

@@ -1,17 +1,17 @@
 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.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,54 +22,28 @@ 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
-def create_temp_time_entries(tmpdir_factory):
-    temporary_directory = tmpdir_factory.mktemp("tmp")
-    json_file = temporary_directory.join("time_entries.json")
-    time_entries = [
-        {
-            "id": Faker().random_int(),
-            "start_date": Faker().date(),
-            "owner_id": Faker().random_int(),
-            "description": Faker().sentence(),
-            "activity_id": Faker().random_int(),
-            "uri": Faker().domain_name(),
-            "technologies": ["jira", "git"],
-            "end_date": Faker().date(),
-            "deleted": Faker().random_int(),
-            "timezone_offset": "300",
-            "project_id": Faker().random_int(),
-        }
-    ]
 
 @pytest.fixture(name='time_entry_factory')
-def _time_entry_factory() -> TimeEntry:
+def _time_entry_factory() -> domain_time_entries.TimeEntry:
     def _make_time_entry(
         id=Faker().random_int(),
-        start_date=Faker().date(),
+        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=Faker().date(),
+        end_date=str(Faker().date_time()),
         deleted=False,
         timezone_offset="300",
         project_id=Faker().random_int(),
     ):
-        time_entry = TimeEntry(
+        time_entry = domain_time_entries.TimeEntry(
             id=id,
             start_date=start_date,
             owner_id=owner_id,

V2/tests/api/azure/time_entry_azure_endpoints_test.py

@@ -15,6 +15,13 @@ def _new_activity(activity: domain.Activity, dao: domain.ActivitiesDao):
     return _new_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='clean_database', autouse=True)
 def _clean_database():
     yield

V2/tests/conftest.py

@@ -0,0 +1,58 @@
+import pytest
+
+
+import time_tracker.time_entries._domain as domain
+import time_tracker.activities._domain as domain_activities
+import time_tracker.time_entries._infrastructure as infrastructure
+import time_tracker.activities._infrastructure as infrastructure_activities
+from time_tracker._infrastructure import DB
+
+
+@pytest.fixture(name='insert_activity')
+def _insert_activity() -> domain_activities.Activity:
+    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
+
+
+@pytest.fixture(name='create_fake_dao')
+def _create_fake_dao() -> domain.TimeEntriesDao:
+    db_fake = DB('sqlite:///:memory:')
+    dao = infrastructure.TimeEntriesJsonDao(db_fake)
+    return dao
+
+
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB('sqlite:///:memory:')
+    dao = infrastructure.TimeEntriesJsonDao(db_fake)
+    query = dao.time_entry.delete()
+    dao.db.get_session().execute(query)
+
+
+def test__time_entry__returns_a_time_entry_dto__when_saves_correctly_with_sql_database(
+    time_entry_factory, create_fake_dao, insert_activity, activity_factory
+):
+    dao = create_fake_dao
+    inserted_activity = insert_activity(activity_factory(), dao.db)
+
+    existent_time_entry = time_entry_factory(activity_id=inserted_activity.id, technologies="[jira,sql]")
+
+    inserted_time_entry = dao.create(existent_time_entry)
+
+    assert isinstance(inserted_time_entry, domain.TimeEntry)
+    assert inserted_time_entry == existent_time_entry
+
+
+def test__time_entry__returns_None__when_not_saves_correctly(
+    time_entry_factory, create_fake_dao,
+):
+    dao = create_fake_dao
+    existent_time_entry = time_entry_factory(activity_id=1203, technologies="[jira,sql]")
+
+    inserted_time_entry = dao.create(existent_time_entry)
+
+    assert inserted_time_entry is None

V2/tests/fixtures.py

@@ -1,16 +1,14 @@
-from faker import Faker
-
 from time_tracker.time_entries._domain import TimeEntryService
 
 
-def test__create_time_entries__uses_the_time_entry_dao__to_create_an_time_entry(mocker):
+def test__create_time_entries__uses_the_time_entry_dao__to_create_an_time_entry(mocker, time_entry_factory):
     expected_time_entry = mocker.Mock()
     time_entry_dao = mocker.Mock(
         create=mocker.Mock(return_value=expected_time_entry)
     )
     time_entry_service = TimeEntryService(time_entry_dao)
 
-    actual_time_entry = time_entry_service.create(Faker().pydict())
+    actual_time_entry = time_entry_service.create(time_entry_factory())
 
     assert time_entry_dao.create.called
     assert expected_time_entry == actual_time_entry