feat: TT-417-crud-v2-projects (#360)

* feat: TT-417 created CRUD project

* test: TT-417 add test with customer id

* refactor: TT-417 created enums and use

* test: TT-417 add missing tests and resolve comments

* refactor: TT-417 add HTTPStatus from http

* refactor: TT-417 test name correction

Co-authored-by: Jipson Murillo <[email protected]>

Author: ararcos

V2/serverless.yml

@@ -97,7 +97,6 @@ functions:
           route: time-entries/{id}
           authLevel: anonymous
 
-    
   update_time_entry:
     handler: time_tracker/time_entries/interface.update_time_entry
     events:
@@ -117,4 +116,43 @@ functions:
             - POST
           route: customers/
           authLevel: anonymous
-         
+
+  get_projects:
+    handler: time_tracker/projects/interface.get_projects
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - GET
+          route: projects/{id:?}
+          authLevel: anonymous
+
+  delete_project:
+    handler: time_tracker/projects/interface.delete_project
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - DELETE
+          route: projects/{id}
+          authLevel: anonymous
+
+  update_project:
+    handler: time_tracker/projects/interface.update_project
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - PUT   
+          route: projects/{id}
+          authLevel: anonymous    
+
+  create_project:
+    handler: time_tracker/projects/interface.create_project
+    events:
+      - http: true
+        x-azure-settings:
+          methods:
+            - POST
+          route: projects/
+          authLevel: anonymous

V2/tests/api/azure/project_azure_endpoints_test.py

@@ -0,0 +1,251 @@
+import json
+from http import HTTPStatus
+
+import pytest
+from faker import Faker
+import azure.functions as func
+
+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
+
+PROJECT_URL = '/api/projects/'
+
+
+@pytest.fixture(name='insert_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(
+    insert_project
+):
+    inserted_projects = [
+        insert_project().__dict__,
+        insert_project().__dict__
+    ]
+
+    req = func.HttpRequest(method='GET', body=None, url=PROJECT_URL)
+    response = azure_projects._get_projects.get_projects(req)
+    projects_json_data = response.get_body().decode("utf-8")
+
+    assert response.status_code == HTTPStatus.OK
+    assert projects_json_data == json.dumps(inserted_projects)
+
+
+def test__project_azure_endpoint__returns_a_project__when_project_matches_its_id(
+    insert_project
+):
+    inserted_project = insert_project().__dict__
+
+    req = func.HttpRequest(
+        method='GET',
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": inserted_project["id"]},
+    )
+
+    response = azure_projects._get_projects.get_projects(req)
+    activitiy_json_data = response.get_body().decode("utf-8")
+
+    assert response.status_code == HTTPStatus.OK
+    assert activitiy_json_data == json.dumps(inserted_project)
+
+
+def test__projects_azure_endpoint__returns_a_status_code_400__when_project_receive_invalid_id(
+):
+    req = func.HttpRequest(
+        method="GET",
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": "invalid id"},
+    )
+
+    response = azure_projects._get_projects.get_projects(req)
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.get_body() == b"Invalid Format ID"
+
+
+def test__project_azure_endpoint__returns_a_project_with_inactive_status__when_a_project_matching_its_id_is_found(
+    insert_project
+):
+    inserted_project = insert_project().__dict__
+
+    req = func.HttpRequest(
+        method='DELETE',
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": inserted_project["id"]},
+    )
+
+    response = azure_projects._delete_project.delete_project(req)
+    project_json_data = json.loads(response.get_body().decode("utf-8"))
+
+    assert response.status_code == HTTPStatus.OK
+    assert project_json_data['status'] == 0
+    assert project_json_data['deleted'] is True
+
+
+def test__delete_projects_azure_endpoint__returns_a_status_code_400__when_project_receive_invalid_id(
+):
+    req = func.HttpRequest(
+        method="DELETE",
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": "invalid id"},
+    )
+
+    response = azure_projects._delete_project.delete_project(req)
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.get_body() == b"Invalid Format ID"
+
+
+def test__delete_projects_azure_endpoint__returns_a_status_code_404__when_no_found_a_project_to_delete(
+):
+    req = func.HttpRequest(
+        method="DELETE",
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": Faker().pyint()},
+    )
+
+    response = azure_projects._delete_project.delete_project(req)
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+    assert response.get_body() == b"Not found"
+
+
+def test__update_project_azure_endpoint__returns_a_project__when_found_a_project_to_update(
+    insert_project
+):
+    inserted_project = insert_project().__dict__
+
+    project_body = {"description": Faker().sentence()}
+    req = func.HttpRequest(
+        method='PUT',
+        body=json.dumps(project_body).encode("utf-8"),
+        url=PROJECT_URL,
+        route_params={"id": inserted_project["id"]},
+    )
+
+    response = azure_projects._update_project.update_project(req)
+    activitiy_json_data = response.get_body().decode("utf-8")
+    inserted_project.update(project_body)
+
+    assert response.status_code == HTTPStatus.OK
+    assert activitiy_json_data == json.dumps(inserted_project)
+
+
+def test__update_projects_azure_endpoint__returns_a_status_code_404__when_no_found_a_project_to_update(
+    project_factory
+):
+    project_body = project_factory().__dict__
+
+    req = func.HttpRequest(
+        method="PUT",
+        body=json.dumps(project_body).encode("utf-8"),
+        url=PROJECT_URL,
+        route_params={"id": project_body["id"]},
+    )
+
+    response = azure_projects._update_project.update_project(req)
+
+    assert response.status_code == HTTPStatus.NOT_FOUND
+    assert response.get_body() == b"Not found"
+
+
+def test__update_projects_azure_endpoint__returns_a_status_code_400__when_receive_an_incorrect_body(
+):
+    project_body = Faker().pydict(5, True, str)
+    req = func.HttpRequest(
+        method="PUT",
+        body=json.dumps(project_body).encode("utf-8"),
+        url=PROJECT_URL,
+        route_params={"id": Faker().pyint()},
+    )
+
+    response = azure_projects._update_project.update_project(req)
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.get_body() == b"Incorrect body"
+
+
+def test__update_projects_azure_endpoint__returns_a_status_code_400__when_project_receive_invalid_id(
+):
+    req = func.HttpRequest(
+        method="PUT",
+        body=None,
+        url=PROJECT_URL,
+        route_params={"id": "invalid id"},
+    )
+
+    response = azure_projects._update_project.update_project(req)
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.get_body() == b"Invalid Format ID"
+
+
+def test__project_azure_endpoint__creates_a_project__when_project_has_all_attributes(
+    test_db, project_factory, insert_customer, customer_factory
+):
+    inserted = insert_customer(customer_factory(), test_db)
+    project_body = project_factory(inserted.id).__dict__
+
+    req = func.HttpRequest(
+         method='POST',
+         body=json.dumps(project_body).encode("utf-8"),
+         url=PROJECT_URL,
+    )
+
+    response = azure_projects._create_project.create_project(req)
+    project_json_data = json.loads(response.get_body())
+    project_body['id'] = project_json_data['id']
+
+    assert response.status_code == HTTPStatus.CREATED
+    assert project_json_data == project_body
+
+
+def test__project_azure_endpoint__returns_a_status_code_400__when_project_does_not_all_attributes(
+    test_db, project_factory, insert_customer, customer_factory
+):
+    inserted_customer = insert_customer(customer_factory(), test_db)
+    project_body = project_factory(customer_id=inserted_customer.id).__dict__
+    project_body.pop('name')
+
+    req = func.HttpRequest(
+         method='POST',
+         body=json.dumps(project_body).encode("utf-8"),
+         url=PROJECT_URL,
+    )
+
+    response = azure_projects._create_project.create_project(req)
+
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert response.get_body() == json.dumps(['The name key is missing in the input data']).encode()
+
+
+def test__project_azure_endpoint__returns_a_status_code_500__when_project_receive_incorrect_type_data(
+    project_factory, insert_customer, customer_factory, test_db
+):
+    insert_customer(customer_factory(), test_db)
+    project_body = project_factory(technologies=Faker().pylist(2, True, str)).__dict__
+
+    req = func.HttpRequest(
+        method='POST',
+        body=json.dumps(project_body).encode("utf-8"),
+        url=PROJECT_URL,
+    )
+
+    response = azure_projects._create_project.create_project(req)
+
+    assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+    assert response.get_body() == b"could not be created"

V2/tests/conftest.py

@@ -1,4 +1,5 @@
 # flake8: noqa
 from fixtures import _activity_factory, _test_db, _insert_activity
 from fixtures import _time_entry_factory
-from fixtures import _customer_factory
+from fixtures import _customer_factory, _insert_customer
+from fixtures import _project_factory

V2/tests/fixtures.py

@@ -2,9 +2,11 @@
 from faker import Faker
 
 import time_tracker.activities._domain as activities_domain
+import time_tracker.activities._infrastructure as activities_infrastructure
 import time_tracker.time_entries._domain as time_entries_domain
 import time_tracker.customers._domain as customers_domain
-import time_tracker.activities._infrastructure as activities_infrastructure
+import time_tracker.customers._infrastructure as customers_infrastructure
+import time_tracker.projects._domain as projects_domain
 from time_tracker._infrastructure import DB
 
 
@@ -94,3 +96,38 @@ def _make_customer(
         return customer
 
     return _make_customer
+
+
+@pytest.fixture(name='project_factory')
+def _project_factory() -> projects_domain.Project:
+    def _make_project(
+        id=Faker().pyint(),
+        name=Faker().name(),
+        description=Faker().sentence(),
+        project_type_id=Faker().pyint(),
+        customer_id=Faker().pyint(),
+        status=Faker().pyint(),
+        deleted=False,
+        technologies=str(Faker().pylist())
+    ):
+        project = projects_domain.Project(
+            id=id,
+            name=name,
+            description=description,
+            project_type_id=project_type_id,
+            customer_id=customer_id,
+            status=status,
+            deleted=deleted,
+            technologies=technologies
+            )
+        return project
+    return _make_project
+
+
+@pytest.fixture(name='insert_customer')
+def _insert_customer() -> customers_domain.Customer:
+    def _new_customer(customer: customers_domain.Customer, database: DB):
+        dao = customers_infrastructure.CustomersSQLDao(database)
+        new_customer = dao.create(customer)
+        return new_customer
+    return _new_customer