feat: TT-401-Post-v2-time-entries

.github/workflows/python-package.yml

@@ -14,6 +14,9 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       max-parallel: 5
+    env:
+      ENVIRONMENT: ${{ secrets.ENVIRONMENT }}
+      TEST_DB_CONNECTION:  ${{ secrets.TEST_DB_CONNECTION }}
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python 3.10.0
@@ -29,14 +32,6 @@ jobs:
       run: |
         pip install -r V2/requirements.txt
 
-    - name: Inject Secrets
-      env:
-        ENVIRONMENT: ${{ secrets.environment }}
-        TEST_DB_CONNECTION: ${{ secrets.test_db_connection }}
-      run: |
-        echo  $ENVIRONMENT
-        echo  $TEST_DB_CONNECTION
-
     - name: Lint with flake8
       run: |
         cd V2

V2/serverless.yml

@@ -76,3 +76,13 @@ functions:
             - POST
           route: activities/
           authLevel: anonymous
+
+  create_time_entry:
+    handler: time_tracker/time_entries/interface.create_time_entry
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - POST
+          route: time-entries/
+          authLevel: anonymous

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -1,34 +1,21 @@
-import pytest
 import json
 from faker import Faker
 
 import azure.functions as func
 
 import time_tracker.activities._application._activities as azure_activities
-import time_tracker.activities._infrastructure as infrastructure
-from time_tracker._infrastructure import DB
-from time_tracker.activities import _domain
 
 ACTIVITY_URL = '/api/activities/'
 
 
-@pytest.fixture(name='insert_activity')
-def _insert_activity() -> dict:
-    def _new_activity(activity: _domain.Activity, database: DB):
-        dao = infrastructure.ActivitiesSQLDao(database)
-        new_activity = dao.create(activity)
-        return new_activity.__dict__
-    return _new_activity
-
-
 def test__activity_azure_endpoint__returns_all_activities(
     create_fake_database, activity_factory, insert_activity
 ):
     fake_database = create_fake_database
     existent_activities = [activity_factory(), activity_factory()]
     inserted_activities = [
-        insert_activity(existent_activities[0], fake_database),
-        insert_activity(existent_activities[1], fake_database)
+        insert_activity(existent_activities[0], fake_database).__dict__,
+        insert_activity(existent_activities[1], fake_database).__dict__
     ]
 
     azure_activities._get_activities.DATABASE = fake_database
@@ -45,7 +32,7 @@ def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_it
 ):
     fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, fake_database).__dict__
 
     azure_activities._get_activities.DATABASE = fake_database
     req = func.HttpRequest(
@@ -67,7 +54,7 @@ def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__whe
 ):
     fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, fake_database).__dict__
 
     azure_activities._delete_activity.DATABASE = fake_database
     req = func.HttpRequest(
@@ -90,7 +77,7 @@ def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_act
 ):
     fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, fake_database).__dict__
 
     azure_activities._update_activity.DATABASE = fake_database
     activity_body = {"description": Faker().sentence()}

V2/tests/api/azure/time_entry_azure_endpoints_test.py

@@ -0,0 +1,29 @@
+import json
+
+import azure.functions as func
+
+import time_tracker.time_entries._application._time_entries as azure_time_entries
+
+TIME_ENTRY_URL = "/api/time-entries/"
+
+
+def test__time_entry_azure_endpoint__creates_an_time_entry__when_time_entry_has_all_attributes(
+    create_fake_database, time_entry_factory, activity_factory, insert_activity
+):
+    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__
+
+    body = json.dumps(time_entry_body).encode("utf-8")
+    req = func.HttpRequest(
+         method='POST',
+         body=body,
+         url=TIME_ENTRY_URL,
+    )
+
+    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 == time_entry_body

V2/tests/conftest.py

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

V2/tests/fixtures.py

@@ -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,49 @@ 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:
-    db_fake = DB('sqlite:///:memory:')
+def _create_fake_database() -> DB:
+    db_fake = DB()
+    db_fake.get_session().execute("pragma foreign_keys=ON")
     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/tests/integration/daos/activities_sql_dao_test.py

@@ -7,12 +7,11 @@
 from time_tracker._infrastructure import DB
 
 
-@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_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)
@@ -41,7 +40,7 @@ def test_update__returns_an_update_activity__when_an_activity_matching_its_id_is
 ):
     dao = create_fake_dao
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, dao)
+    inserted_activity = insert_activity(existent_activity, dao.db)
 
     expected_description = Faker().sentence()
     updated_activity = dao.update(inserted_activity.id, None, expected_description, None, None)
@@ -68,8 +67,8 @@ def test__get_all__returns_a_list_of_activity_dto_objects__when_one_or_more_acti
     dao = create_fake_dao
     existent_activities = [activity_factory(), activity_factory()]
     inserted_activities = [
-        insert_activity(existent_activities[0], dao),
-        insert_activity(existent_activities[1], dao)
+        insert_activity(existent_activities[0], dao.db),
+        insert_activity(existent_activities[1], dao.db)
     ]
 
     activities = dao.get_all()
@@ -83,7 +82,7 @@ def test_get_by_id__returns_an_activity_dto__when_found_one_activity_that_matche
 ):
     dao = create_fake_dao
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, dao)
+    inserted_activity = insert_activity(existent_activity, dao.db)
 
     activity = dao.get_by_id(inserted_activity.id)
 
@@ -117,7 +116,7 @@ def test_delete__returns_an_activity_with_inactive_status__when_an_activity_matc
 ):
     dao = create_fake_dao
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, dao)
+    inserted_activity = insert_activity(existent_activity, dao.db)
 
     activity = dao.delete(inserted_activity.id)
 

V2/tests/integration/daos/time_entries_dao_test.py

@@ -0,0 +1,48 @@
+import pytest
+
+
+import time_tracker.time_entries._domain as domain
+import time_tracker.time_entries._infrastructure as infrastructure
+from time_tracker._infrastructure import DB
+
+
+@pytest.fixture(name='create_fake_dao')
+def _fake_dao() -> domain.TimeEntriesDao:
+    def _create_fake_dao(db_fake: DB) -> domain.TimeEntriesDao:
+        dao = infrastructure.TimeEntriesSQLDao(db_fake)
+        return dao
+    return _create_fake_dao
+
+
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB()
+    dao = infrastructure.TimeEntriesSQLDao(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(
+    create_fake_database, time_entry_factory, create_fake_dao, insert_activity, activity_factory
+):
+    dao = create_fake_dao(create_fake_database)
+    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)
+
+    assert isinstance(inserted_time_entry, domain.TimeEntry)
+    assert inserted_time_entry == time_entry_to_insert
+
+
+def test__time_entry__returns_None__when_not_saves_correctly(
+    time_entry_factory, create_fake_dao, create_fake_database
+):
+    dao = create_fake_dao(create_fake_database)
+    time_entry_to_insert = time_entry_factory(activity_id=1203, technologies="[jira,sql]")
+
+    inserted_time_entry = dao.create(time_entry_to_insert)
+
+    assert inserted_time_entry is None