TT-357 Create V2 Activities Azure DAO

V2/.flake8

@@ -1,4 +1,4 @@
 [flake8]
-exclude = .git,__pycache__,./node_modules,
+exclude = .git,__pycache__,./node_modules,.venv
 max-complexity = 10
 max_line_length = 120

V2/Makefile

@@ -4,4 +4,5 @@ install:
 		pip install --upgrade pip
 		pip install -r requirements.txt
 		@echo "Completed! "
-
+start-local:
+		docker compose up

V2/create_activity/function.json

@@ -0,0 +1,22 @@
+{
+  "disabled": false,
+  "bindings": [
+    {
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "route": "activities/",
+      "authLevel": "anonymous",
+      "methods": [
+        "POST"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ],
+  "entryPoint": "create_activity",
+  "scriptFile": "../time_tracker/activities/interface.py"
+}

V2/delete_activity/function.json

@@ -0,0 +1,22 @@
+{
+  "disabled": false,
+  "bindings": [
+    {
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "route": "activities/{id}",
+      "authLevel": "anonymous",
+      "methods": [
+        "DELETE"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ],
+  "entryPoint": "delete_activity",
+  "scriptFile": "../time_tracker/activities/interface.py"
+}

V2/docker-compose.yml

@@ -0,0 +1,10 @@
+version: '3.9'
+services:
+  database:
+    image: postgres:14
+    ports:
+      - "5433:5432"
+    environment:
+      - POSTGRES_USER=${DB_USER}
+      - POSTGRES_PASSWORD=${DB_PASS}
+      - POSTGRES_DB=${DB_NAME}

V2/get_activities/function.json

@@ -0,0 +1,22 @@
+{
+  "disabled": false,
+  "bindings": [
+    {
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "route": "activities/{id:?}",
+      "authLevel": "anonymous",
+      "methods": [
+        "GET"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "$return"
+    }
+  ],
+  "entryPoint": "get_activities",
+  "scriptFile": "../time_tracker/activities/interface.py"
+}

V2/requirements.txt

@@ -10,4 +10,8 @@ flake8==4.0.1
 pytest-mock
 
 # To create sample content in tests and API documentation
-Faker==4.0.2
+Faker==4.0.2
+
+#SQL ALCHEMY
+SQLAlchemy==1.4.24
+psycopg2==2.9.1

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -1,108 +1,135 @@
-from time_tracker.activities._application import _activities as activities
+import pytest
+import json
 from faker import Faker
 
 import azure.functions as func
-import json
 
+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/'
 
-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_temp_activities,
+    create_fake_database, activity_factory, insert_activity
 ):
-    activities_json, tmp_directory = create_temp_activities
-    activities._get_activities.JSON_PATH = tmp_directory
-    req = func.HttpRequest(method="GET", body=None, url=ACTIVITY_URL)
-
-    response = activities.get_activities(req)
+    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)
+    ]
+
+    azure_activities._get_activities.DATABASE = fake_database
+    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")
 
     assert response.status_code == 200
-    assert activities_json_data == json.dumps(activities_json)
+    assert activities_json_data == json.dumps(inserted_activities)
 
 
 def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_its_id(
-    create_temp_activities,
+    create_fake_database, activity_factory, insert_activity
 ):
-    activities_json, tmp_directory = create_temp_activities
-    activities._get_activities.JSON_PATH = tmp_directory
+    fake_database = create_fake_database
+    existent_activity = activity_factory()
+    inserted_activity = insert_activity(existent_activity, fake_database)
+
+    azure_activities._get_activities.DATABASE = fake_database
     req = func.HttpRequest(
-        method="GET",
+        method='GET',
         body=None,
         url=ACTIVITY_URL,
-        route_params={"id": activities_json[0]["id"]},
+        route_params={"id": inserted_activity["id"]},
     )
 
-    response = activities.get_activities(req)
+    response = azure_activities._get_activities.get_activities(req)
     activitiy_json_data = response.get_body().decode("utf-8")
 
     assert response.status_code == 200
-    assert activitiy_json_data == json.dumps(activities_json[0])
+    assert activitiy_json_data == json.dumps(inserted_activity)
 
 
 def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found(
-    create_temp_activities,
+    create_fake_database, activity_factory, insert_activity
 ):
-    activities_json, tmp_directory = create_temp_activities
-    activities._delete_activity.JSON_PATH = tmp_directory
+    fake_database = create_fake_database
+    existent_activity = activity_factory()
+    inserted_activity = insert_activity(existent_activity, fake_database)
+
+    azure_activities._delete_activity.DATABASE = fake_database
     req = func.HttpRequest(
-        method="DELETE",
+        method='DELETE',
         body=None,
         url=ACTIVITY_URL,
-        route_params={"id": activities_json[0]["id"]},
+        route_params={"id": inserted_activity["id"]},
     )
 
-    response = activities.delete_activity(req)
+    response = azure_activities._delete_activity.delete_activity(req)
     activity_json_data = json.loads(response.get_body().decode("utf-8"))
 
     assert response.status_code == 200
-    assert activity_json_data["status"] == "inactive"
+    assert activity_json_data['status'] == 0
+    assert activity_json_data['deleted'] is True
 
 
 def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_activity_to_update(
-    create_temp_activities,
+    create_fake_database, activity_factory, insert_activity
 ):
-    activities_json, tmp_directory = create_temp_activities
-    activities._update_activity.JSON_PATH = tmp_directory
-    activity_data = {"description": Faker().sentence()}
+    fake_database = create_fake_database
+    existent_activity = activity_factory()
+    inserted_activity = insert_activity(existent_activity, fake_database)
+
+    azure_activities._update_activity.DATABASE = fake_database
+    activity_body = {"description": Faker().sentence()}
     req = func.HttpRequest(
-        method="PUT",
-        body=json.dumps(activity_data).encode("utf-8"),
+        method='PUT',
+        body=json.dumps(activity_body).encode("utf-8"),
         url=ACTIVITY_URL,
-        route_params={"id": activities_json[0]["id"]},
+        route_params={"id": inserted_activity["id"]},
     )
 
-    response = activities.update_activity(req)
+    response = azure_activities._update_activity.update_activity(req)
     activitiy_json_data = response.get_body().decode("utf-8")
-    new_activity = {**activities_json[0], **activity_data}
+    inserted_activity.update(activity_body)
 
     assert response.status_code == 200
-    assert activitiy_json_data == json.dumps(new_activity)
+    assert activitiy_json_data == json.dumps(inserted_activity)
 
 
 def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_attributes(
-    create_temp_activities,
-):
-    activities_json, tmp_directory = create_temp_activities
-    activities._create_activity._JSON_PATH = tmp_directory
-
+     create_fake_database,
+ ):
+    azure_activities._create_activity.DATABASE = create_fake_database
     activity_body = {
-        "id": None,
-        "name": Faker().user_name(),
-        "description": Faker().sentence(),
-        "deleted": Faker().uuid4(),
-        "status": "active",
-        "tenant_id": Faker().uuid4(),
+        'id': None,
+        'name': Faker().user_name(),
+        'description': Faker().sentence(),
+        'deleted': False,
+        'status': 1
     }
     body = json.dumps(activity_body).encode("utf-8")
     req = func.HttpRequest(
-        method="POST",
-        body=body,
-        url=ACTIVITY_URL,
+         method='POST',
+         body=body,
+         url=ACTIVITY_URL,
     )
 
-    response = activities.create_activity(req)
-    activitiy_json_data = response.get_body()
+    response = azure_activities._create_activity.create_activity(req)
+    activitiy_json_data = json.loads(response.get_body())
+    activity_body['id'] = activitiy_json_data['id']
+
     assert response.status_code == 201
-    assert activitiy_json_data == body
+    assert activitiy_json_data == activity_body

V2/tests/conftest.py

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

V2/tests/fixtures.py

@@ -0,0 +1,35 @@
+import pytest
+
+import time_tracker.activities._domain as domain
+import time_tracker.activities._infrastructure as infrastructure
+from time_tracker._infrastructure import DB
+from faker import Faker
+
+
+@pytest.fixture(name='activity_factory')
+def _activity_factory() -> domain.Activity:
+    def _make_activity(
+        name: str = Faker().name(), description: str = Faker().sentence(), deleted: bool = False, status: int = 1
+    ):
+        activity = domain.Activity(
+            id=None,
+            name=name,
+            description=description,
+            deleted=deleted,
+            status=status
+            )
+        return 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:')
+    return db_fake