feat: TT-401-Post-v2-time-entries (#344)

* feat: TT-401 Implemented service, end-point, dao, test- time entries

* feat: TT-401 validated request create time entry

* fix: TT-401 implemented faker url

* refactor: TT-401 changed the variable name

* fix: implementation of the database connection

* refactor: TT-401 fixtures changed

* fix: TT-401 solution of comments, change of config

* ci: TT-401 fix inject secrets

* refactor: TT-401 rename of functions and imports

* fix: TT-401 changed test db storage

Author: ararcos

.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/create_activity/function.json

@@ -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/delete_activity/function.json

@@ -1,37 +1,24 @@
-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
+    test_db, 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], test_db).__dict__,
+        insert_activity(existent_activities[1], test_db).__dict__
     ]
 
-    azure_activities._get_activities.DATABASE = fake_database
+    azure_activities._get_activities.DATABASE = test_db
+
     req = func.HttpRequest(method='GET', body=None, url=ACTIVITY_URL)
     response = azure_activities._get_activities.get_activities(req)
     activities_json_data = response.get_body().decode("utf-8")
@@ -41,13 +28,12 @@ def test__activity_azure_endpoint__returns_all_activities(
 
 
 def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_its_id(
-    create_fake_database, activity_factory, insert_activity
+    test_db, activity_factory, insert_activity
 ):
-    fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, test_db).__dict__
 
-    azure_activities._get_activities.DATABASE = fake_database
+    azure_activities._get_activities.DATABASE = test_db
     req = func.HttpRequest(
         method='GET',
         body=None,
@@ -63,13 +49,12 @@ def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_it
 
 
 def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found(
-    create_fake_database, activity_factory, insert_activity
+    test_db, activity_factory, insert_activity
 ):
-    fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, test_db).__dict__
 
-    azure_activities._delete_activity.DATABASE = fake_database
+    azure_activities._delete_activity.DATABASE = test_db
     req = func.HttpRequest(
         method='DELETE',
         body=None,
@@ -86,13 +71,12 @@ def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__whe
 
 
 def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_activity_to_update(
-    create_fake_database, activity_factory, insert_activity
+    test_db, activity_factory, insert_activity
 ):
-    fake_database = create_fake_database
     existent_activity = activity_factory()
-    inserted_activity = insert_activity(existent_activity, fake_database)
+    inserted_activity = insert_activity(existent_activity, test_db).__dict__
 
-    azure_activities._update_activity.DATABASE = fake_database
+    azure_activities._update_activity.DATABASE = test_db
     activity_body = {"description": Faker().sentence()}
     req = func.HttpRequest(
         method='PUT',
@@ -109,10 +93,7 @@ def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_act
     assert activitiy_json_data == json.dumps(inserted_activity)
 
 
-def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_attributes(
-     create_fake_database,
- ):
-    azure_activities._create_activity.DATABASE = create_fake_database
+def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_attributes():
     activity_body = {
         'id': None,
         'name': Faker().user_name(),

V2/get_activities/function.json

@@ -0,0 +1,28 @@
+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(
+    test_db, time_entry_factory, activity_factory, insert_activity
+):
+    inserted_activity = insert_activity(activity_factory(), test_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/serverless.yml

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

V2/tests/api/azure/activity_azure_endpoints_test.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 activities_domain
+import time_tracker.activities._infrastructure as activities_infrastructure
+import time_tracker.time_entries._domain as time_entries_domain
 from time_tracker._infrastructure import DB
-from faker import Faker
 
 
 @pytest.fixture(name='activity_factory')
-def _activity_factory() -> domain.Activity:
+def _activity_factory() -> activities_domain.Activity:
     def _make_activity(
         name: str = Faker().name(), description: str = Faker().sentence(), deleted: bool = False, status: int = 1
     ):
-        activity = domain.Activity(
+        activity = activities_domain.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='test_db')
+def _test_db() -> DB:
+    db_fake = DB()
+    db_fake.get_session().execute("pragma foreign_keys=ON")
+    return db_fake
 
 
-@pytest.fixture(name='create_fake_database')
-def _create_fake_database() -> domain.ActivitiesDao:
-    db_fake = DB('sqlite:///:memory:')
-    return db_fake
+@pytest.fixture(name='time_entry_factory')
+def _time_entry_factory() -> time_entries_domain.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 = time_entries_domain.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: activities_domain.Activity, database: DB):
+        dao = activities_infrastructure.ActivitiesSQLDao(database)
+        new_activity = dao.create(activity)
+        return new_activity
+    return _new_activity

V2/tests/api/azure/time_entry_azure_endpoints_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)