test: TT-417 add test of projects

Author: Jobzi

V2/tests/api/azure/project_azure_endpoints_test.py

@@ -0,0 +1,165 @@
+import json
+
+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
+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
+    return _new_project
+
+
+def test__project_azure_endpoint__returns_all_projects(
+    test_db, project_factory, insert_project
+):
+    project_to_insert = [project_factory(), project_factory()]
+    inserted_projects = [
+        insert_project(project_to_insert[0], test_db).__dict__,
+        insert_project(project_to_insert[1], test_db).__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 == 200
+    assert projects_json_data == json.dumps(inserted_projects)
+
+
+def test__project_azure_endpoint__returns_an_project__when_project_matches_its_id(
+    test_db, project_factory, insert_project
+):
+    project_to_insert = project_factory()
+    inserted_project = insert_project(project_to_insert, test_db).__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 == 200
+    assert activitiy_json_data == json.dumps(inserted_project)
+
+
+def test__projects_azure_endpoint__returns_a_status_code_400__when_project_recive_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 == 400
+    assert response.get_body() == b'Invalid Format ID'
+
+
+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
+):
+    project_to_insert = project_factory()
+    inserted_project = insert_project(project_to_insert, test_db).__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 == 200
+    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_recive_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 == 400
+    assert response.get_body() == b'Invalid Format ID'
+
+
+def test__update_project_azure_endpoint__returns_an_project__when_found_an_project_to_update(
+    test_db, project_factory, insert_project
+):
+    project_to_insert = project_factory()
+    inserted_project = insert_project(project_to_insert, test_db).__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 == 200
+    assert activitiy_json_data == json.dumps(inserted_project)
+
+
+def test__update_projects_azure_endpoint__returns_a_status_code_400__when_project_recive_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 == 400
+    assert response.get_body() == b'Invalid Format ID'
+
+
+def test__project_azure_endpoint__creates_an_project__when_project_has_all_attributes(
+    project_factory
+):
+    project_body = project_factory().__dict__
+    body = json.dumps(project_body).encode("utf-8")
+    req = func.HttpRequest(
+         method='POST',
+         body=body,
+         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 == 201
+    assert project_json_data == project_body

V2/tests/conftest.py

@@ -2,3 +2,4 @@
 from fixtures import _activity_factory, _test_db, _insert_activity
 from fixtures import _time_entry_factory
 from fixtures import _customer_factory
+from fixtures import _project_factory

V2/tests/fixtures.py

@@ -2,9 +2,10 @@
 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.projects._domain as projects_domain
 from time_tracker._infrastructure import DB
 
 
@@ -94,3 +95,27 @@ 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

V2/tests/integration/daos/projects_dao_test.py

@@ -0,0 +1,136 @@
+import pytest
+import typing
+from faker import Faker
+
+from time_tracker.projects import _domain as domain
+from time_tracker.projects import _infrastructure as infrastructure
+from time_tracker._infrastructure import DB
+
+
+@pytest.fixture(name='create_fake_dao')
+def _create_fake_dao() -> domain.ProjectsDao:
+    db_fake = DB()
+    dao = infrastructure.ProjectsSQLDao(db_fake)
+    return dao
+
+
+@pytest.fixture(name='clean_database', autouse=True)
+def _clean_database():
+    yield
+    db_fake = DB()
+    dao = infrastructure.ProjectsSQLDao(db_fake)
+    query = dao.project.delete()
+    dao.db.get_session().execute(query)
+
+
+def test__create_project__returns_a_project_dto__when_saves_correctly_with_sql_database(
+    create_fake_dao, project_factory
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+
+    inserted_project = dao.create(project_to_insert)
+
+    assert isinstance(inserted_project, domain.Project)
+    assert inserted_project == project_to_insert
+
+
+def test_update__returns_an_update_project__when_an_project_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, project_factory
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+    inserted_project = dao.create(project_to_insert)
+
+    expected_description = Faker().sentence()
+    updated_project = dao.update(inserted_project.id, {"description": expected_description})
+
+    assert isinstance(updated_project, domain.Project)
+    assert updated_project.id == inserted_project.id
+    assert updated_project.description == expected_description
+
+
+def test_update__returns_none__when_no_project_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, project_factory
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+
+    results = dao.update(project_to_insert.id,  {"description": Faker().sentence()})
+
+    assert results is None
+
+
+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
+):
+    dao = create_fake_dao
+    project_to_inserts = [project_factory(), project_factory()]
+    inserted_projects = [
+        dao.create(project_to_inserts[0]),
+        dao.create(project_to_inserts[1])
+    ]
+
+    projects = dao.get_all()
+    assert isinstance(projects, typing.List)
+    assert projects == inserted_projects
+
+
+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
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+    inserted_project = dao.create(project_to_insert)
+
+    project = dao.get_by_id(inserted_project.id)
+
+    assert isinstance(project, domain.Project)
+    assert project.id == inserted_project.id
+    assert project == inserted_project
+
+
+def test__get_by_id__returns_none__when_no_project_matches_its_id_with_sql_database(
+    create_fake_dao, project_factory
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+
+    project = dao.get_by_id(project_to_insert.id)
+
+    assert project is None
+
+
+def test_get_all__returns_an_empty_list__when_doesnt_found_any_projects_with_sql_database(
+    create_fake_dao
+):
+    projects = create_fake_dao.get_all()
+
+    assert isinstance(projects, typing.List)
+    assert projects == []
+
+
+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
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+    inserted_project = dao.create(project_to_insert)
+
+    project = dao.delete(inserted_project.id)
+
+    assert isinstance(project, domain.Project)
+    assert project.id == inserted_project.id
+    assert project.status == 0
+    assert project.deleted is True
+
+
+def test_delete__returns_none__when_no_project_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, project_factory
+):
+    dao = create_fake_dao
+    project_to_insert = project_factory()
+
+    results = dao.delete(project_to_insert.id)
+
+    assert results is None