refactor: TT-357 Refactor tests, and activity data

Author: dsgarcia8

V2/serverless.yml

@@ -38,7 +38,7 @@ package:
 
 functions:
   get_activities:
-    handler: time_entries/interface.get_activities
+    handler: time_tracker/activities/interface.get_activities
     events:
       - http: true
         x-azure-settings:
@@ -48,7 +48,7 @@ functions:
           authLevel: anonymous
 
   delete_activity:
-    handler: time_entries/interface.delete_activity
+    handler: time_tracker/activities/interface.delete_activity
     events:
       - http: true
         x-azure-settings:
@@ -58,7 +58,7 @@ functions:
           authLevel: anonymous
 
   update_activity:
-    handler: time_entries/interface.update_activity
+    handler: time_tracker/activities/interface.update_activity
     events:
       - http: true
         x-azure-settings:
@@ -68,7 +68,7 @@ functions:
           authLevel: anonymous    
 
   create_activity:
-    handler: time_entries/interface.create_activity
+    handler: time_tracker/activities/interface.create_activity
     events:
       - http: true
         x-azure-settings:

V2/tests/api/api_fixtures.py

@@ -0,0 +1,22 @@
+import pytest
+
+import time_tracker.activities._domain as domain 
+import time_tracker.activities._infrastructure as infrastructure 
+
+@pytest.fixture(name='activity_factory')
+def _activity_factory() -> domain.Activity:
+    def _make_activity(data: dict):
+        activity = domain.Activity(**data)
+        return activity
+    return _make_activity    
+
+@pytest.fixture(name='create_fake_dao')
+def _create_fake_dao() -> domain.ActivitiesDao:
+    db_fake = infrastructure.DB('sqlite:///:memory:')
+    dao = infrastructure.ActivitiesSQLDao(db_fake)
+    return dao
+
+@pytest.fixture(name='create_fake_database')
+def _create_fake_database() -> domain.ActivitiesDao:
+    db_fake = infrastructure.DB('sqlite:///:memory:')
+    return db_fake

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -1,15 +1,14 @@
 import pytest
 import json
-import uuid
 from faker import Faker
 
 import azure.functions as func
 import sqlalchemy
 from sqlalchemy.sql.sqltypes import Integer
 
-import time_entries._application._activities as azure_activities
-import time_entries._domain as domain 
-import time_entries._infrastructure as infrastructure 
+import time_tracker.activities._application._activities as azure_activities
+import time_tracker.activities._domain as domain 
+import time_tracker.activities._infrastructure as infrastructure 
 
 ACTIVITY_URL = '/api/activities/'
 
@@ -18,122 +17,127 @@
         'id': 1,
         'name': 'Activity Demo create',
         'description': 'test demo create an new activity',
-        'deleted': 'b4327ba6-9f96-49ee-a9ac-3c1edf525172',
-        'status': 'active',
-        'tenant_id': 'cc925a5d-9644-4a4f-8d99-0bee49aadd05',
+        'deleted': None,
+        'status': None,
         },
         {
         'id': 2,
         'name': 'Activity Demo create',
         'description': 'test demo create an new activity',
-        'deleted': 'b4327ba6-9f96-49ee-a9ac-3c1edf525172',
-        'status': 'active',
-        'tenant_id': 'cc925a5d-9644-4a4f-8d99-0bee49aadd05',
+        'deleted':  None,
+        'status': None,
         },
     ]
 
-@pytest.fixture(name='create_fake_database')
-def _create_fake_database() -> domain.ActivitiesDao:
-    db_fake = infrastructure.DB('sqlite:///:memory:')
-    
-    activity = sqlalchemy.Table('activity', db_fake.metadata,
-                    sqlalchemy.Column('id',sqlalchemy.Integer, primary_key=True,autoincrement=True),
-                    sqlalchemy.Column('name', sqlalchemy.String),
-                    sqlalchemy.Column('description', sqlalchemy.String),
-                    sqlalchemy.Column('deleted', sqlalchemy.String),
-                    sqlalchemy.Column('status', sqlalchemy.String),
-                    sqlalchemy.Column('tenant_id', sqlalchemy.String),
-                     extend_existing=True,
-              )
-
-    query = activity.insert()
-    db_fake.get_session().execute(query, DEMO_DATA)
-    return db_fake
+
+@pytest.fixture(name='insert_activity')
+def _insert_activity() -> domain.Activity:
+    def _new_activity(activity: dict, database: infrastructure.DB):
+        dao = infrastructure.ActivitiesSQLDao(database)
+        new_activity = dao.create(activity)
+        return new_activity
+    return _new_activity
 
 def test__activity_azure_endpoint__returns_all_activities(
-    create_fake_database,
+    create_fake_database, activity_factory, insert_activity
 ):
-    azure_activities._get_activities.DATABASE = create_fake_database
-    req = func.HttpRequest(method='GET', body=None, url=ACTIVITY_URL)
+    fake_database = create_fake_database
+    existent_activities= [activity_factory(DEMO_DATA[0]), activity_factory(DEMO_DATA[1])]
+    inserted_activities = [insert_activity(existent_activities[0].__dict__, fake_database).__dict__, insert_activity(existent_activities[1].__dict__, fake_database).__dict__]
 
+    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(DEMO_DATA)
+    assert activities_json_data == json.dumps(inserted_activities)
 
 
 def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_its_id(
-    create_fake_database,
+    create_fake_database, activity_factory, insert_activity
 ):
-    azure_activities._get_activities.DATABASE = create_fake_database
+    fake_database = create_fake_database
+    existent_activity= activity_factory(DEMO_DATA[0])
+    inserted_activity = insert_activity(existent_activity.__dict__, fake_database).__dict__
+
+    azure_activities._get_activities.DATABASE = fake_database
     req = func.HttpRequest(
         method='GET',
         body=None,
         url=ACTIVITY_URL,
-        route_params={"id": str(DEMO_DATA[0]['id'])},
+        route_params={"id": inserted_activity["id"]},
     )
 
     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(DEMO_DATA[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_fake_database,
-):
-    azure_activities._delete_activity.DATABASE = create_fake_database
+    create_fake_database,activity_factory, insert_activity
+):  
+    fake_database = create_fake_database
+    existent_activity= activity_factory(DEMO_DATA[0])
+    inserted_activity = insert_activity(existent_activity.__dict__, fake_database).__dict__
+
+    azure_activities._delete_activity.DATABASE = fake_database
     req = func.HttpRequest(
         method='DELETE',
         body=None,
         url=ACTIVITY_URL,
-        route_params={"id": str(DEMO_DATA[0]['id'])},
+        route_params={"id": inserted_activity["id"]},
     )
 
     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'] == True
 
 
 def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_activity_to_update(
-    create_fake_database,
+    create_fake_database, activity_factory, insert_activity
 ):
-    azure_activities._update_activity.DATABASE = create_fake_database
+    fake_database = create_fake_database
+    existent_activity= activity_factory(DEMO_DATA[0])
+    inserted_activity = insert_activity(existent_activity.__dict__, fake_database).__dict__
+
+    azure_activities._update_activity.DATABASE = fake_database
     activity_body = {"description": Faker().sentence()}
     req = func.HttpRequest(
         method='PUT',
         body=json.dumps(activity_body).encode("utf-8"),
         url=ACTIVITY_URL,
-        route_params={"id": str(DEMO_DATA[0]['id'])},
+        route_params={"id": inserted_activity["id"]},
     )
 
     response = azure_activities._update_activity.update_activity(req)
     activitiy_json_data = response.get_body().decode("utf-8")
-    new_activity = {**DEMO_DATA[0], **activity_body}
+    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_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()}
+     activity_body = {'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,
      )
 
-
      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 ==  activity_body

V2/tests/conftest.py

@@ -0,0 +1 @@
+from tests.api.api_fixtures import _activity_factory, _create_fake_dao, _create_fake_database