refactor: TT-417 created enums and use

V2/tests/api/azure/project_azure_endpoints_test.py

@@ -7,29 +7,28 @@
 from time_tracker.projects._application import _projects as azure_projects
 from time_tracker.projects import _domain as domain
 from time_tracker.projects import _infrastructure as infrastructure
-from time_tracker._infrastructure import DB
 
 PROJECT_URL = '/api/projects/'
 
 
 @pytest.fixture(name='insert_project')
-def _insert_project() -> domain.Project:
-    def _new_project(project: domain.Project, database: DB):
-        dao = infrastructure.ProjectsSQLDao(database)
-        new_project = dao.create(project)
-        return new_project
+def insert_project(test_db, insert_customer, project_factory, customer_factory) -> domain.Project:
+    inserted_customer = insert_customer(customer_factory(), test_db)
+
+    def _new_project():
+        project_to_insert = project_factory(customer_id=inserted_customer.id)
+        dao = infrastructure.ProjectsSQLDao(test_db)
+        inserted_project = dao.create(project_to_insert)
+        return inserted_project
     return _new_project
 
 
 def test__project_azure_endpoint__returns_all_projects(
-    test_db, project_factory, insert_project, insert_customer, customer_factory
+    insert_project
 ):
-    inserted_customer = insert_customer(customer_factory(), test_db)
-    project_to_insert = [project_factory(customer_id=inserted_customer.id),
-                         project_factory(customer_id=inserted_customer.id)]
     inserted_projects = [
-        insert_project(project_to_insert[0], test_db).__dict__,
-        insert_project(project_to_insert[1], test_db).__dict__
+        insert_project().__dict__,
+        insert_project().__dict__
     ]
 
     req = func.HttpRequest(method='GET', body=None, url=PROJECT_URL)
@@ -41,11 +40,9 @@ def test__project_azure_endpoint__returns_all_projects(
 
 
 def test__project_azure_endpoint__returns_an_project__when_project_matches_its_id(
-    test_db, project_factory, insert_project, insert_customer, customer_factory
+    insert_project
 ):
-    inserted_customer = insert_customer(customer_factory(), test_db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
-    inserted_project = insert_project(project_to_insert, test_db).__dict__
+    inserted_project = insert_project().__dict__
 
     req = func.HttpRequest(
         method='GET',
@@ -77,11 +74,9 @@ def test__projects_azure_endpoint__returns_a_status_code_400__when_project_reciv
 
 
 def test__project_azure_endpoint__returns_an_project_with_inactive_status__when_an_project_matching_its_id_is_found(
-    test_db, project_factory, insert_project, insert_customer, customer_factory
+    insert_project
 ):
-    inserted_customer = insert_customer(customer_factory(), test_db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
-    inserted_project = insert_project(project_to_insert, test_db).__dict__
+    inserted_project = insert_project().__dict__
 
     req = func.HttpRequest(
         method='DELETE',
@@ -114,11 +109,9 @@ def test__delete_projects_azure_endpoint__returns_a_status_code_400__when_projec
 
 
 def test__update_project_azure_endpoint__returns_an_project__when_found_an_project_to_update(
-    test_db, project_factory, insert_project, insert_customer, customer_factory
+    insert_project
 ):
-    inserted_customer = insert_customer(customer_factory(), test_db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
-    inserted_project = insert_project(project_to_insert, test_db).__dict__
+    inserted_project = insert_project().__dict__
 
     project_body = {"description": Faker().sentence()}
     req = func.HttpRequest(

V2/tests/fixtures.py

@@ -125,9 +125,9 @@ def _make_project(
 
 
 @pytest.fixture(name='insert_customer')
-def _insert_customer() -> dict:
-    def _new_customer(activity: customers_domain.Customer, database: DB):
+def _insert_customer() -> customers_domain.Customer:
+    def _new_customer(customer: customers_domain.Customer, database: DB):
         dao = customers_infrastructure.CustomersSQLDao(database)
-        new_activity = dao.create(activity)
-        return new_activity
+        new_customer = dao.create(customer)
+        return new_customer
     return _new_customer

V2/tests/integration/daos/projects_dao_test.py

@@ -7,6 +7,18 @@
 from time_tracker._infrastructure import DB
 
 
+@pytest.fixture(name='insert_project')
+def _insert_project(customer_factory, test_db, insert_customer, create_fake_dao, project_factory) -> domain.Project:
+    inserted_customer = insert_customer(customer_factory(), test_db)
+
+    def _new_project():
+        project_to_insert = project_factory(customer_id=inserted_customer.id)
+        inserted_project = create_fake_dao.create(project_to_insert)
+        return inserted_project
+
+    return _new_project
+
+
 @pytest.fixture(name='create_fake_dao')
 def _create_fake_dao() -> domain.ProjectsDao:
     db_fake = DB()
@@ -37,13 +49,11 @@ def test__create_project__returns_a_project_dto__when_saves_correctly_with_sql_d
 
 
 def test_update__returns_an_update_project__when_an_project_matching_its_id_is_found_with_sql_database(
-    create_fake_dao, project_factory, insert_customer, customer_factory
+    create_fake_dao, insert_project
 ):
     dao = create_fake_dao
-    inserted_customer = insert_customer(customer_factory(), dao.db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
 
-    inserted_project = dao.create(project_to_insert)
+    inserted_project = insert_project()
 
     expected_description = Faker().sentence()
     updated_project = dao.update(inserted_project.id, {"description": expected_description})
@@ -65,16 +75,13 @@ def test_update__returns_none__when_no_project_matching_its_id_is_found_with_sql
 
 
 def test__get_all__returns_a_list_of_project_dto_objects__when_one_or_more_projects_are_found_with_sql_database(
-    create_fake_dao, project_factory, insert_customer, customer_factory
+    create_fake_dao, insert_project
 ):
     dao = create_fake_dao
-    inserted_customer = insert_customer(customer_factory(), dao.db)
-    project_to_inserts = [project_factory(customer_id=inserted_customer.id),
-                          project_factory(customer_id=inserted_customer.id)]
 
     inserted_projects = [
-        dao.create(project_to_inserts[0]),
-        dao.create(project_to_inserts[1])
+        insert_project(),
+        insert_project()
     ]
 
     projects = dao.get_all()
@@ -83,13 +90,11 @@ def test__get_all__returns_a_list_of_project_dto_objects__when_one_or_more_proje
 
 
 def test_get_by_id__returns_an_project_dto__when_found_one_project_that_matches_its_id_with_sql_database(
-    create_fake_dao, project_factory, insert_customer, customer_factory
+    create_fake_dao, insert_project
 ):
     dao = create_fake_dao
-    inserted_customer = insert_customer(customer_factory(), dao.db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
 
-    inserted_project = dao.create(project_to_insert)
+    inserted_project = insert_project()
 
     project = dao.get_by_id(inserted_project.id)
 
@@ -119,12 +124,11 @@ def test_get_all__returns_an_empty_list__when_doesnt_found_any_projects_with_sql
 
 
 def test_delete__returns_an_project_with_inactive_status__when_an_project_matching_its_id_is_found_with_sql_database(
-    create_fake_dao, project_factory, insert_customer, customer_factory
+    create_fake_dao, insert_project
 ):
     dao = create_fake_dao
-    inserted_customer = insert_customer(customer_factory(), dao.db)
-    project_to_insert = project_factory(customer_id=inserted_customer.id)
-    inserted_project = dao.create(project_to_insert)
+
+    inserted_project = insert_project()
 
     project = dao.delete(inserted_project.id)
 

V2/time_tracker/projects/_application/_projects/_create_project.py

@@ -7,6 +7,7 @@
 from ... import _domain
 from ... import _infrastructure
 from time_tracker._infrastructure import DB
+from time_tracker.utils.enums import ResponseEnums as enums
 
 
 def create_project(req: func.HttpRequest) -> func.HttpResponse:
@@ -19,34 +20,30 @@ def create_project(req: func.HttpRequest) -> func.HttpResponse:
 
     validation_errors = _validate_project(project_data)
     if validation_errors:
-        return func.HttpResponse(
-            body=json.dumps(validation_errors), status_code=400, mimetype="application/json"
+        status_code = enums.STATUS_BAD_REQUEST.value
+        response = json.dumps(validation_errors)
+    else:
+        project_to_create = _domain.Project(
+          id=None,
+          name=project_data["name"],
+          description=project_data["description"],
+          project_type_id=project_data["project_type_id"],
+          customer_id=project_data["customer_id"],
+          status=project_data["status"],
+          deleted=False,
+          technologies=project_data["technologies"]
         )
 
-    project_to_create = _domain.Project(
-      id=None,
-      name=project_data["name"],
-      description=project_data["description"],
-      project_type_id=project_data["project_type_id"],
-      customer_id=project_data["customer_id"],
-      status=project_data["status"],
-      deleted=False,
-      technologies=project_data["technologies"]
-    )
-
-    created_project = use_case.create_project(project_to_create)
+        created_project = use_case.create_project(project_to_create)
 
-    if not created_project:
-        return func.HttpResponse(
-          body=json.dumps({'error': 'project could not be created'}),
-          status_code=500,
-          mimetype="application/json"
-        )
+        status_code, response = [
+          enums.INTERNAL_SERVER_ERROR.value, json.dumps({'error': f'project {enums.NOT_CREATED.value}'})
+        ] if not created_project else [enums.STATUS_CREATED.value, json.dumps(created_project.__dict__)]
 
     return func.HttpResponse(
-      body=json.dumps(created_project.__dict__),
-      status_code=201,
-      mimetype="application/json"
+      body=response,
+      status_code=status_code,
+      mimetype=enums.MIME_TYPE.value
     )
 
 

V2/time_tracker/projects/_application/_projects/_delete_project.py

@@ -5,6 +5,7 @@
 from ... import _domain
 from ... import _infrastructure
 from time_tracker._infrastructure import DB
+from time_tracker.utils.enums import ResponseEnums as enums
 
 
 def delete_project(req: func.HttpRequest) -> func.HttpResponse:
@@ -15,22 +16,20 @@ def delete_project(req: func.HttpRequest) -> func.HttpResponse:
     try:
         project_id = int(req.route_params.get("id"))
         deleted_project = use_case.delete_project(project_id)
-        if not deleted_project:
-            return func.HttpResponse(
-                body="Not found",
-                status_code=404,
-                mimetype="application/json"
-            )
+
+        status_code, response = [
+          enums.STATUS_NOT_FOUND.value, enums.NOT_FOUND.value.encode()
+        ] if not deleted_project else [enums.STATUS_OK.value, json.dumps(deleted_project.__dict__)]
 
         return func.HttpResponse(
-            body=json.dumps(deleted_project.__dict__, default=str),
-            status_code=200,
-            mimetype="application/json",
+            body=response,
+            status_code=status_code,
+            mimetype=enums.MIME_TYPE.value,
         )
 
     except ValueError:
         return func.HttpResponse(
-            body=b"Invalid Format ID",
-            status_code=400,
-            mimetype="application/json"
+            body=enums.INVALID_ID.value.encode(),
+            status_code=enums.STATUS_BAD_REQUEST.value,
+            mimetype=enums.MIME_TYPE.value
         )

V2/time_tracker/projects/_application/_projects/_get_projects.py

@@ -6,6 +6,7 @@
 from ... import _domain
 from ... import _infrastructure
 from time_tracker._infrastructure import DB
+from time_tracker.utils.enums import ResponseEnums as enums
 
 
 def get_projects(req: func.HttpRequest) -> func.HttpResponse:
@@ -20,24 +21,24 @@ def get_projects(req: func.HttpRequest) -> func.HttpResponse:
             response = _get_by_id(int(project_id), project_service)
             if not response:
                 return func.HttpResponse(
-                    body="Not found",
-                    status_code=404,
-                    mimetype="application/json"
+                    body=enums.NOT_FOUND.value.encode(),
+                    status_code=enums.STATUS_NOT_FOUND.value,
+                    mimetype=enums.MIME_TYPE.value
                 )
         else:
             response = _get_all(project_service)
 
         return func.HttpResponse(
-            body=json.dumps(response, default=str),
-            status_code=200,
-            mimetype="application/json",
+            body=json.dumps(response),
+            status_code=enums.STATUS_OK.value,
+            mimetype=enums.MIME_TYPE.value,
         )
 
     except ValueError:
         return func.HttpResponse(
-            body=b"Invalid Format ID",
-            status_code=400,
-            mimetype="application/json"
+            body=enums.INVALID_ID.value.encode(),
+            status_code=enums.STATUS_BAD_REQUEST.value,
+            mimetype=enums.MIME_TYPE.value
         )
 
 

V2/time_tracker/projects/_application/_projects/_update_project.py

@@ -6,6 +6,7 @@
 from ... import _domain
 from ... import _infrastructure
 from time_tracker._infrastructure import DB
+from time_tracker.utils.enums import ResponseEnums as enums
 
 
 def update_project(req: func.HttpRequest) -> func.HttpResponse:
@@ -17,29 +18,28 @@ def update_project(req: func.HttpRequest) -> func.HttpResponse:
     try:
         project_id = int(req.route_params.get("id"))
         project_data = req.get_json()
-        status_code = 200
 
         if not _validate_project(project_data):
-            status_code = 400
-            response = "Incorrect project body"
+            status_code = enums.STATUS_BAD_REQUEST.value
+            response = bytes(f"{enums.INCORRECT_BODY.value} project")
 
-        response = use_case.update_project(project_id, project_data).__dict__
-
-        if not update_project:
-            status_code = 404
-            response = "Not found"
+        else:
+            updated_project = use_case.update_project(project_id, project_data)
+            status_code, response = [
+              enums.STATUS_NOT_FOUND.value, enums.NOT_FOUND.value.encode()
+            ] if not updated_project else [enums.STATUS_OK.value, json.dumps(updated_project.__dict__)]
 
         return func.HttpResponse(
-            body=json.dumps(response, default=str),
+            body=response,
             status_code=status_code,
-            mimetype="application/json",
+            mimetype=enums.MIME_TYPE.value,
         )
 
     except ValueError:
         return func.HttpResponse(
-            body=b"Invalid Format ID",
-            status_code=400,
-            mimetype="application/json"
+            body=enums.INVALID_ID.value.encode(),
+            status_code=enums.STATUS_BAD_REQUEST.value,
+            mimetype=enums.MIME_TYPE.value,
         )
 
 

V2/time_tracker/utils/enums/__init__.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+from .response_enums import ResponseEnums

V2/time_tracker/utils/enums/response_enums.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class ResponseEnums(Enum):
+    STATUS_CREATED = 201
+    STATUS_OK = 200
+    STATUS_BAD_REQUEST = 400
+    STATUS_NOT_FOUND = 404
+    INTERNAL_SERVER_ERROR = 500
+
+    INVALID_ID = "Invalid Format ID"
+    NOT_FOUND = "Not found"
+    NOT_CREATED = "could not be created"
+    INCORRECT_BODY = "Incorrect body"
+
+    MIME_TYPE = "application/json"