feat: TT-365 Method POST activity and create function serverless

Author: dsgarcia8

V2/serverless.yml

@@ -49,10 +49,20 @@ functions:
 
   delete_activity:
     handler: time_entries/interface.delete_activity
+      events:
+        - http: true
+          x-azure-settings:
+            methods:
+              - DELETE
+            route: activities/{id}
+            authLevel: anonymous
+
+  create_activity:
+    handler: time_entries/interface.create_activity
     events:
       - http: true
         x-azure-settings:
           methods:
-            - DELETE
-          route: activities/{id}
-          authLevel: anonymous
+            - POST
+          route: activities/
+          authLevel: anonymous

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -1,11 +1,12 @@
 from time_entries._application._activities import (
     _get_activities,
     _delete_activity,
+    _create_activity
 )
 import azure.functions as func
 import json
 import typing
-
+from faker import Faker
 
 def test__activity_azure_endpoint__returns_all_activities(
     create_temp_activities,
@@ -57,3 +58,23 @@ def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__whe
 
     assert response.status_code == 200
     assert activity_json_data['status'] == 'inactive'
+def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_attributes(
+    create_temp_activities,
+):
+    activities_json, tmp_directory = create_temp_activities
+    _create_activity.JSON_PATH = tmp_directory
+
+    activity_body = {'id': Faker().uuid4(), 'name': Faker().user_name(), 'description': Faker().sentence(),'deleted': Faker().uuid4() ,'status': 'active', 'tenant_id': Faker().uuid4()}
+    body = json.dumps(activity_body).encode("utf-8")
+    req = func.HttpRequest(
+        method='POST',
+        body= body,
+        url='/api/activities/',
+    )
+
+    response = _create_activity.create_activity(req)
+    activitiy_json_data = response.get_body()
+
+    assert response.status_code == 200
+    assert activitiy_json_data ==  body
+

V2/tests/integration/daos/activities_json_dao_test.py

@@ -84,6 +84,20 @@ def test_get_all__returns_an_empty_list__when_doesnt_found_any_activities(
 
     assert result == activities
 
+def test_create_activity__returns_an_activity_dto__when_create_an_activity_that_matches_attributes(create_fake_activities):
+     create_fake_activities([])
+
+     activities_json_dao = ActivitiesJsonDao(Faker().file_path())
+     activity_data = {
+                 "name": "test_name",
+                 "description": "test_description",
+                 "tenant_id": "test_tenant_id",
+                 "id": "test_id",
+                 "deleted": "test_deleted",
+                 "status": "test_status",
+             }
+     result = activities_json_dao.create_activity(activity_data)
+     assert result == Activity(**activity_data)
 
 def test_delete__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found(
     create_fake_activities,
@@ -116,4 +130,4 @@ def test_delete__returns_none__when_no_activity_matching_its_id_is_found(
 
     result = activities_json_dao.delete(Faker().uuid4())
 
-    assert result is None
+    assert result is None

V2/tests/unit/services/activity_service_test.py

@@ -41,3 +41,15 @@ def test__delete_activity__uses_the_activity_dao__to_change_activity_status(
 
     assert activity_dao.delete.called
     assert expected_activity == deleted_activity
+
+def test__create_activity__uses_the_activity_dao__to_create_an_activity(mocker):
+    expected_activity = mocker.Mock()
+    activity_dao = mocker.Mock(
+        create_activity=mocker.Mock(return_value=expected_activity)
+    )
+    activity_service = ActivityService(activity_dao)
+
+    actual_activity = activity_service.create_activity(Faker().pydict())
+
+    assert activity_dao.create_activity.called
+    assert expected_activity == actual_activity

V2/tests/unit/use_cases/activities_use_case_test.py

@@ -35,6 +35,19 @@ def test__get_activity_by_id_function__uses_the_activity_service__to_retrieve_ac
     assert activity_service.get_by_id.called
     assert expected_activity == actual_activity
 
+def test__create_activity_function__uses_the_activities_service__to_create_activity(
+     mocker: MockFixture,
+ ):
+     expected_activity = mocker.Mock()
+     activity_service = mocker.Mock(
+         create_activity=mocker.Mock(return_value=expected_activity)
+     )
+
+     activity_use_case = _use_cases.CreateActivityUseCase(activity_service)
+     actual_activity = activity_use_case.create_activity(fake.pydict())
+
+     assert activity_service.create_activity.called
+     assert expected_activity == actual_activity
 
 def test__delete_activity_function__uses_the_activity_service__to_change_activity_status(
     mocker: MockFixture,
@@ -48,4 +61,4 @@ def test__delete_activity_function__uses_the_activity_service__to_change_activit
     deleted_activity = activity_use_case.delete_activity(fake.uuid4())
 
     assert activity_service.delete.called
-    assert expected_activity == deleted_activity
+    assert expected_activity == deleted_activity

V2/time_entries/_application/__init__.py

@@ -1,2 +1 @@
-from ._activities import get_activities
-from ._activities import delete_activity
+from ._activities import get_activities, create_activity, delete_activity

V2/time_entries/_application/_activities/__init__.py

@@ -1,2 +1,3 @@
 from ._get_activities import get_activities
 from ._delete_activity import delete_activity
+from ._create_activity import create_activity

V2/time_entries/_application/_activities/_create_activity.py

@@ -0,0 +1,49 @@
+from time_entries._infrastructure import ActivitiesJsonDao
+from time_entries._domain import ActivityService, _use_cases, Activity
+
+import azure.functions as func
+import json
+import logging
+import dataclasses
+
+
+JSON_PATH = (
+
+    '::WqV2/time_entries/_infrastructure/_data_persistence/activities_data.json'
+)
+
+
+
+def create_activity(req: func.HttpRequest) -> func.HttpResponse:
+    logging.info(
+        'Python HTTP trigger function processed a request to create an activity.'
+    )
+    activity_data = req.get_json()
+    status_code = 200
+    if _validate_activity(activity_data):
+        response = _create_activity(activity_data)
+    else:
+        status_code = 404
+        response = b'Not possible to create activity, attributes are not correct '
+
+    return func.HttpResponse(
+        body=response, status_code=status_code, mimetype="application/json"
+    )
+
+def _create_activity(activity_data: dict) -> str:
+    activity_use_case = _use_cases.CreateActivityUseCase(
+        _create_activity_service(JSON_PATH)
+    )
+    activity = activity_use_case.create_activity(activity_data)
+    return json.dumps(activity.__dict__) if activity else b'Not Found'
+
+def _validate_activity(activity_data: dict) -> bool:
+    activity_keys = [field.name for field in dataclasses.fields(Activity)]
+    new_activity_keys = list(activity_data.keys())
+    return  all(map(lambda key: key in activity_keys, new_activity_keys)) and len(activity_keys) == len(new_activity_keys)
+
+def _create_activity_service(path: str):
+    activity_json = ActivitiesJsonDao(path)
+    return ActivityService(activity_json)
+
+

V2/time_entries/_domain/_persistence_contracts/_activities_dao.py

@@ -12,6 +12,10 @@ def get_by_id(self, id: str) -> Activity:
     def get_all(self) -> typing.List[Activity]:
         pass
 
+    @abc.abstractmethod
+    def create_activity(self, activity_data: dict) -> Activity:
+         pass
+
     @abc.abstractmethod
     def delete(self, id: str) -> Activity:
-        pass
+        pass

V2/time_entries/_domain/_services/_activity.py

@@ -14,3 +14,6 @@ def get_all(self) -> typing.List[Activity]:
 
     def delete(self, activity_id: str) -> Activity:
         return self.activities_dao.delete(activity_id)
+
+    def create_activity(self, activity_data: dict) -> Activity:
+        return self.activities_dao.create_activity(activity_data)