Close #55 Create activity model for Cosmos DB

Author: EliuX

commons/data_access_layer/cosmos_db.py

@@ -168,28 +168,31 @@ def __init__(self, repository: CosmosDBRepository):
         self.repository = repository
 
     def get_all(self) -> list:
-        tenant_id: str = current_user_tenant_id()
+        tenant_id: str = self.partition_key_value
         return self.repository.find_all(partition_key_value=tenant_id)
 
     def get(self, id):
-        tenant_id: str = current_user_tenant_id()
+        tenant_id: str = self.partition_key_value
         return self.repository.find(id, partition_key_value=tenant_id)
 
     def create(self, data: dict):
         data['id'] = str(uuid.uuid4())
-        data['tenant_id'] = current_user_tenant_id()
+        data['tenant_id'] = self.partition_key_value
         return self.repository.create(data)
 
     def update(self, id, data: dict):
-        tenant_id: str = current_user_tenant_id()
         return self.repository.partial_update(id,
                                               changes=data,
-                                              partition_key_value=tenant_id)
+                                              partition_key_value=self.partition_key_value)
 
     def delete(self, id):
         tenant_id: str = current_user_tenant_id()
         self.repository.delete(id, partition_key_value=tenant_id)
 
+    @property
+    def partition_key_value(self):
+        return current_user_tenant_id()
+
 
 def init_app(app: Flask) -> None:
     global cosmos_helper

tests/time_tracker_api/activities/activities_namespace_test.py

@@ -1,8 +1,10 @@
 from faker import Faker
 from flask import json
 from flask.testing import FlaskClient
-from pytest_mock import MockFixture
 from flask_restplus._http import HTTPStatus
+from pytest_mock import MockFixture
+
+from time_tracker_api.security import current_user_tenant_id
 
 fake = Faker()
 
@@ -26,7 +28,7 @@ def test_create_activity_should_succeed_with_valid_request(client: FlaskClient,
     response = client.post("/activities", json=valid_activity_data, follow_redirects=True)
 
     assert HTTPStatus.CREATED == response.status_code
-    repository_create_mock.assert_called_once_with(valid_activity_data)
+    repository_create_mock.assert_called_once()
 
 
 def test_create_activity_should_reject_bad_request(client: FlaskClient, mocker: MockFixture):
@@ -54,7 +56,7 @@ def test_list_all_activities(client: FlaskClient, mocker: MockFixture):
     assert [] == json_data
     repository_find_all_mock.assert_called_once()
 
-#HEY
+
 def test_get_activity_should_succeed_with_valid_id(client: FlaskClient, mocker: MockFixture):
     from time_tracker_api.activities.activities_namespace import activity_dao
 
@@ -68,7 +70,8 @@ def test_get_activity_should_succeed_with_valid_id(client: FlaskClient, mocker:
 
     assert HTTPStatus.OK == response.status_code
     fake_activity == json.loads(response.data)
-    repository_find_mock.assert_called_once_with(str(valid_id))
+    repository_find_mock.assert_called_once_with(str(valid_id),
+                                                 partition_key_value=current_user_tenant_id())
 
 
 def test_get_activity_should_return_not_found_with_invalid_id(client: FlaskClient, mocker: MockFixture):
@@ -84,7 +87,8 @@ def test_get_activity_should_return_not_found_with_invalid_id(client: FlaskClien
     response = client.get("/activities/%s" % invalid_id, follow_redirects=True)
 
     assert HTTPStatus.NOT_FOUND == response.status_code
-    repository_find_mock.assert_called_once_with(str(invalid_id))
+    repository_find_mock.assert_called_once_with(str(invalid_id),
+                                                 partition_key_value=current_user_tenant_id())
 
 
 def test_get_activity_should_return_422_for_invalid_id_format(client: FlaskClient, mocker: MockFixture):
@@ -100,28 +104,31 @@ def test_get_activity_should_return_422_for_invalid_id_format(client: FlaskClien
     response = client.get("/activities/%s" % invalid_id, follow_redirects=True)
 
     assert HTTPStatus.UNPROCESSABLE_ENTITY == response.status_code
-    repository_find_mock.assert_called_once_with(str(invalid_id))
+    repository_find_mock.assert_called_once_with(str(invalid_id),
+                                                 partition_key_value=current_user_tenant_id())
 
 
 def test_update_activity_should_succeed_with_valid_data(client: FlaskClient, mocker: MockFixture):
     from time_tracker_api.activities.activities_namespace import activity_dao
 
     repository_update_mock = mocker.patch.object(activity_dao.repository,
-                                                 'update',
+                                                 'partial_update',
                                                  return_value=fake_activity)
 
     valid_id = fake.random_int(1, 9999)
     response = client.put("/activities/%s" % valid_id, json=valid_activity_data, follow_redirects=True)
 
     assert HTTPStatus.OK == response.status_code
     fake_activity == json.loads(response.data)
-    repository_update_mock.assert_called_once_with(str(valid_id), valid_activity_data)
+    repository_update_mock.assert_called_once_with(str(valid_id),
+                                                   changes=valid_activity_data,
+                                                   partition_key_value=current_user_tenant_id())
 
 
 def test_update_activity_should_reject_bad_request(client: FlaskClient, mocker: MockFixture):
     from time_tracker_api.activities.activities_namespace import activity_dao
     repository_update_mock = mocker.patch.object(activity_dao.repository,
-                                                 'update',
+                                                 'partial_update',
                                                  return_value=fake_activity)
 
     valid_id = fake.random_int(1, 9999)
@@ -138,15 +145,17 @@ def test_update_activity_should_return_not_found_with_invalid_id(client: FlaskCl
     invalid_id = fake.random_int(1, 9999)
 
     repository_update_mock = mocker.patch.object(activity_dao.repository,
-                                                 'update',
+                                                 'partial_update',
                                                  side_effect=NotFound)
 
     response = client.put("/activities/%s" % invalid_id,
                           json=valid_activity_data,
                           follow_redirects=True)
 
     assert HTTPStatus.NOT_FOUND == response.status_code
-    repository_update_mock.assert_called_once_with(str(invalid_id), valid_activity_data)
+    repository_update_mock.assert_called_once_with(str(invalid_id),
+                                                   changes=valid_activity_data,
+                                                   partition_key_value=current_user_tenant_id())
 
 
 def test_delete_activity_should_succeed_with_valid_id(client: FlaskClient, mocker: MockFixture):
@@ -155,14 +164,15 @@ def test_delete_activity_should_succeed_with_valid_id(client: FlaskClient, mocke
     valid_id = fake.random_int(1, 9999)
 
     repository_remove_mock = mocker.patch.object(activity_dao.repository,
-                                                 'remove',
+                                                 'delete',
                                                  return_value=None)
 
     response = client.delete("/activities/%s" % valid_id, follow_redirects=True)
 
     assert HTTPStatus.NO_CONTENT == response.status_code
     assert b'' == response.data
-    repository_remove_mock.assert_called_once_with(str(valid_id))
+    repository_remove_mock.assert_called_once_with(str(valid_id),
+                                                   partition_key_value=current_user_tenant_id())
 
 
 def test_delete_activity_should_return_not_found_with_invalid_id(client: FlaskClient, mocker: MockFixture):
@@ -172,13 +182,14 @@ def test_delete_activity_should_return_not_found_with_invalid_id(client: FlaskCl
     invalid_id = fake.random_int(1, 9999)
 
     repository_remove_mock = mocker.patch.object(activity_dao.repository,
-                                                 'remove',
+                                                 'delete',
                                                  side_effect=NotFound)
 
     response = client.delete("/activities/%s" % invalid_id, follow_redirects=True)
 
     assert HTTPStatus.NOT_FOUND == response.status_code
-    repository_remove_mock.assert_called_once_with(str(invalid_id))
+    repository_remove_mock.assert_called_once_with(str(invalid_id),
+                                                   partition_key_value=current_user_tenant_id())
 
 
 def test_delete_activity_should_return_422_for_invalid_id_format(client: FlaskClient, mocker: MockFixture):
@@ -188,10 +199,11 @@ def test_delete_activity_should_return_422_for_invalid_id_format(client: FlaskCl
     invalid_id = fake.company()
 
     repository_remove_mock = mocker.patch.object(activity_dao.repository,
-                                                 'remove',
+                                                 'delete',
                                                  side_effect=UnprocessableEntity)
 
     response = client.delete("/activities/%s" % invalid_id, follow_redirects=True)
 
     assert HTTPStatus.UNPROCESSABLE_ENTITY == response.status_code
-    repository_remove_mock.assert_called_once_with(str(invalid_id))
+    repository_remove_mock.assert_called_once_with(str(invalid_id),
+                                                   partition_key_value=current_user_tenant_id())

tests/time_tracker_api/projects/projects_namespace_test.py

@@ -135,7 +135,7 @@ def test_update_project_should_reject_bad_request(client: FlaskClient, mocker: M
         "project_type_id": fake.pyint(min_value=1, max_value=100),
     })
     repository_update_mock = mocker.patch.object(project_dao.repository,
-                                                 'update',
+                                                 'partial_update',
                                                  return_value=fake_project)
 
     valid_id = fake.random_int(1, 9999)

time_tracker_api/activities/activities_model.py

@@ -1,39 +1,15 @@
+from dataclasses import dataclass
+
 from azure.cosmos import PartitionKey
 
+from commons.data_access_layer.cosmos_db import CosmosDBModel, CosmosDBDao, CosmosDBRepository
 from commons.data_access_layer.database import CRUDDao
 
 
 class ActivityDao(CRUDDao):
     pass
 
 
-def create_dao() -> ActivityDao:
-    from sqlalchemy_utils import UUIDType
-    import uuid
-    from commons.data_access_layer.sql import db
-    from commons.data_access_layer.sql import SQLCRUDDao
-
-    class ActivitySQLModel(db.Model):
-        __tablename__ = 'activity'
-        id = db.Column(UUIDType(binary=False), primary_key=True, default=uuid.uuid4)
-        name = db.Column(db.String(50), unique=True, nullable=False)
-        description = db.Column(db.String(250), unique=False, nullable=False)
-        deleted = db.Column(UUIDType(binary=False), default=uuid.uuid4)
-        tenant_id = db.Column(UUIDType(binary=False), default=uuid.uuid4)
-
-        def __repr__(self):
-            return '<Activity %r>' % self.name
-
-        def __str___(self):
-            return "the activity \"%s\"" % self.name
-
-    class ActivitySQLDao(ActivityDao, SQLCRUDDao):
-        def __init__(self):
-            SQLCRUDDao.__init__(self, ActivitySQLModel)
-
-    return ActivitySQLDao()
-
-
 container_definition = {
     'id': 'activity',
     'partition_key': PartitionKey(path='/tenant_id'),
@@ -43,3 +19,32 @@ def __init__(self):
         ]
     }
 }
+
+
+@dataclass()
+class ActivityCosmosDBModel(CosmosDBModel):
+    id: str
+    name: str
+    description: str
+    deleted: str
+    tenant_id: str
+
+    def __init__(self, data):
+        super(ActivityCosmosDBModel, self).__init__(data)
+
+    def __repr__(self):
+        return '<Activity %r>' % self.name
+
+    def __str___(self):
+        return "the activity \"%s\"" % self.name
+
+
+def create_dao() -> ActivityDao:
+    repository = CosmosDBRepository.from_definition(container_definition,
+                                                    mapper=ActivityCosmosDBModel)
+
+    class ActivityCosmosDBDao(CosmosDBDao, ActivityDao):
+        def __init__(self):
+            CosmosDBDao.__init__(self, repository)
+
+    return ActivityCosmosDBDao()

time_tracker_api/activities/activities_namespace.py

@@ -22,12 +22,6 @@
         title='Description',
         description='Comments about the activity',
         example=faker.paragraph(),
-    ),
-    'tenant_id': fields.String(
-        required=True,
-        title='Identifier of Tenant',
-        description='Tenant this activity belongs to',
-        example=faker.uuid4(),
     )
 })
 
@@ -39,6 +33,12 @@
         description='The unique identifier',
         example=faker.uuid4(),
     ),
+    'tenant_id': fields.String(
+        required=True,
+        title='Identifier of Tenant',
+        description='Tenant this activity belongs to',
+        example=faker.uuid4(),
+    ),
 }
 activity_response_fields.update(audit_fields)
 

time_tracker_api/projects/projects_model.py

@@ -5,19 +5,11 @@
 from commons.data_access_layer.cosmos_db import CosmosDBModel, CosmosDBDao, CosmosDBRepository
 from commons.data_access_layer.database import CRUDDao
 
-"""
-Protocols
-"""
-
 
 class ProjectDao(CRUDDao):
     pass
 
 
-"""
-Cosmos DB
-"""
-
 container_definition = {
     'id': 'project',
     'partition_key': PartitionKey(path='/tenant_id'),