Refactor: TT-357 correction of FlakeV8

V2/tests/api/azure/activity_azure_endpoints_test.py

@@ -5,11 +5,12 @@
 import azure.functions as func
 
 import time_tracker.activities._application._activities as azure_activities
-import time_tracker.activities._infrastructure as infrastructure 
+import time_tracker.activities._infrastructure as infrastructure
 from time_tracker._infrastructure import DB
 
 ACTIVITY_URL = '/api/activities/'
 
+
 @pytest.fixture(name='insert_activity')
 def _insert_activity() -> dict:
     def _new_activity(activity: dict, database: DB):
@@ -18,18 +19,22 @@ def _new_activity(activity: dict, database: DB):
         return new_activity.__dict__
     return _new_activity
 
+
 def test__activity_azure_endpoint__returns_all_activities(
     create_fake_database, activity_factory, insert_activity
 ):
     fake_database = create_fake_database
-    existent_activities= [activity_factory(), activity_factory()]
-    inserted_activities = [insert_activity(existent_activities[0].__dict__, fake_database), insert_activity(existent_activities[1].__dict__, fake_database)]
+    existent_activities = [activity_factory(), activity_factory()]
+    inserted_activities = [
+        insert_activity(existent_activities[0].__dict__, fake_database),
+        insert_activity(existent_activities[1].__dict__, fake_database)
+    ]
 
     azure_activities._get_activities.DATABASE = fake_database
     req = func.HttpRequest(method='GET', body=None, url=ACTIVITY_URL)
     response = azure_activities._get_activities.get_activities(req)
     activities_json_data = response.get_body().decode("utf-8")
-   
+
     assert response.status_code == 200
     assert activities_json_data == json.dumps(inserted_activities)
 
@@ -38,7 +43,7 @@ def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_it
     create_fake_database, activity_factory, insert_activity
 ):
     fake_database = create_fake_database
-    existent_activity= activity_factory()
+    existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, fake_database)
 
     azure_activities._get_activities.DATABASE = fake_database
@@ -57,10 +62,10 @@ def test__activity_azure_endpoint__returns_an_activity__when_activity_matches_it
 
 
 def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found(
-    create_fake_database,activity_factory, insert_activity
-):  
+    create_fake_database, activity_factory, insert_activity
+):
     fake_database = create_fake_database
-    existent_activity= activity_factory()
+    existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, fake_database)
 
     azure_activities._delete_activity.DATABASE = fake_database
@@ -76,14 +81,14 @@ def test__activity_azure_endpoint__returns_an_activity_with_inactive_status__whe
 
     assert response.status_code == 200
     assert activity_json_data['status'] == 0
-    assert activity_json_data['deleted'] == True
+    assert activity_json_data['deleted'] is True
 
 
 def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_activity_to_update(
     create_fake_database, activity_factory, insert_activity
 ):
     fake_database = create_fake_database
-    existent_activity= activity_factory()
+    existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, fake_database)
 
     azure_activities._update_activity.DATABASE = fake_database
@@ -106,18 +111,24 @@ def test__update_activity_azure_endpoint__returns_an_activity__when_found_an_act
 def test__activity_azure_endpoint__creates_an_activity__when_activity_has_all_attributes(
      create_fake_database,
  ):
-     azure_activities._create_activity.DATABASE = create_fake_database
-     activity_body = {'id': None, 'name': Faker().user_name(), 'description': Faker().sentence(),'deleted': False ,'status': 1}
-     body = json.dumps(activity_body).encode("utf-8")
-     req = func.HttpRequest(
+    azure_activities._create_activity.DATABASE = create_fake_database
+    activity_body = {
+        'id': None,
+        'name': Faker().user_name(),
+        'description': Faker().sentence(),
+        'deleted': False,
+        'status': 1
+    }
+    body = json.dumps(activity_body).encode("utf-8")
+    req = func.HttpRequest(
          method='POST',
-         body= body,
+         body=body,
          url=ACTIVITY_URL,
-     )
-     
-     response = azure_activities._create_activity.create_activity(req)
-     activitiy_json_data = json.loads(response.get_body())
-     activity_body['id'] = activitiy_json_data['id']
-
-     assert response.status_code == 201
-     assert activitiy_json_data ==  activity_body
+    )
+
+    response = azure_activities._create_activity.create_activity(req)
+    activitiy_json_data = json.loads(response.get_body())
+    activity_body['id'] = activitiy_json_data['id']
+
+    assert response.status_code == 201
+    assert activitiy_json_data == activity_body

V2/tests/api_fixtures.py

@@ -8,7 +8,9 @@
 
 @pytest.fixture(name='activity_factory')
 def _activity_factory() -> domain.Activity:
-    def _make_activity(name: str = Faker().name(), description: str = Faker().sentence(), deleted: bool = False, status: int = 1):
+    def _make_activity(
+        name: str = Faker().name(), description: str = Faker().sentence(), deleted: bool = False, status: int = 1
+    ):
         activity = domain.Activity(
             id=None,
             name=name,

V2/tests/conftest.py

@@ -1 +1,2 @@
+# flake8: noqa
 from api_fixtures import _activity_factory, _create_fake_dao, _create_fake_database

V2/tests/integration/daos/activities_sql_dao_test.py

@@ -1,8 +1,8 @@
 import pytest
 import typing
 
-import time_tracker.activities._domain as domain 
-import time_tracker.activities._infrastructure as infrastructure 
+import time_tracker.activities._domain as domain
+import time_tracker.activities._infrastructure as infrastructure
 from time_tracker._infrastructure import DB
 
 
@@ -13,6 +13,7 @@ def _new_activity(activity: dict, dao: domain.ActivitiesDao):
         return new_activity
     return _new_activity
 
+
 @pytest.fixture(name='clean_database', autouse=True)
 def _clean_database():
     yield
@@ -21,49 +22,63 @@ def _clean_database():
     query = dao.activity.delete()
     dao.db.get_session().execute(query)
 
-def test__create_activity__returns_a_activity_dto__when_saves_correctly_with_sql_database(create_fake_dao, activity_factory):
+
+def test__create_activity__returns_a_activity_dto__when_saves_correctly_with_sql_database(
+    create_fake_dao, activity_factory
+):
     dao = create_fake_dao
     existent_activity = activity_factory()
-    
+
     inserted_activity = dao.create(existent_activity.__dict__)
-    
+
     assert isinstance(inserted_activity, domain.Activity)
     assert inserted_activity == existent_activity
 
 
-def test_update__returns_an_update_activity__when_an_activity_matching_its_id_is_found_with_sql_database(create_fake_dao, activity_factory, insert_activity):
+def test_update__returns_an_update_activity__when_an_activity_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, activity_factory, insert_activity
+):
     dao = create_fake_dao
     existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, dao)
-    
+
     updated_activity = dao.update(inserted_activity.id, {'description': 'test demo 2 create an new activity'})
-    
+
     assert isinstance(updated_activity, domain.Activity)
     assert updated_activity.id == inserted_activity.id
     assert updated_activity.description == 'test demo 2 create an new activity'
 
 
-def test_update__returns_none__when_no_activity_matching_its_id_is_found_with_sql_database(create_fake_dao, activity_factory):
+def test_update__returns_none__when_no_activity_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, activity_factory
+):
     dao = create_fake_dao
     existent_activity = activity_factory()
 
-    results = dao.update(existent_activity.id,{'description': 'test demo'})
-    
-    assert results == None
-  
+    results = dao.update(existent_activity.id, {'description': 'test demo'})
+
+    assert results is None
+
 
-def test__get_all__returns_a_list_of_activity_dto_objects__when_one_or_more_activities_are_found_with_sql_database(create_fake_dao, activity_factory, insert_activity):
+def test__get_all__returns_a_list_of_activity_dto_objects__when_one_or_more_activities_are_found_with_sql_database(
+    create_fake_dao, activity_factory, insert_activity
+):
     dao = create_fake_dao
-    existent_activities= [activity_factory(), activity_factory()]
-    inserted_activities = [insert_activity(existent_activities[0].__dict__, dao), insert_activity(existent_activities[1].__dict__, dao)]
+    existent_activities = [activity_factory(), activity_factory()]
+    inserted_activities = [
+        insert_activity(existent_activities[0].__dict__, dao),
+        insert_activity(existent_activities[1].__dict__, dao)
+    ]
 
     activities = dao.get_all()
 
     assert isinstance(activities, typing.List)
     assert activities == inserted_activities
 
 
-def test_get_by_id__returns_an_activity_dto__when_found_one_activity_that_matches_its_id_with_sql_database(create_fake_dao, activity_factory, insert_activity):
+def test_get_by_id__returns_an_activity_dto__when_found_one_activity_that_matches_its_id_with_sql_database(
+    create_fake_dao, activity_factory, insert_activity
+):
     dao = create_fake_dao
     existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, dao)
@@ -75,23 +90,29 @@ def test_get_by_id__returns_an_activity_dto__when_found_one_activity_that_matche
     assert activity == inserted_activity
 
 
-def test__get_by_id__returns_none__when_no_activity_matches_its_id_with_sql_database(create_fake_dao, activity_factory): 
+def test__get_by_id__returns_none__when_no_activity_matches_its_id_with_sql_database(
+    create_fake_dao, activity_factory
+):
     dao = create_fake_dao
-    existent_activity = activity_factory()  
+    existent_activity = activity_factory()
 
     activity = dao.get_by_id(existent_activity.id)
 
-    assert activity == None
+    assert activity is None
 
 
-def test_get_all__returns_an_empty_list__when_doesnt_found_any_activities_with_sql_database(create_fake_dao):
+def test_get_all__returns_an_empty_list__when_doesnt_found_any_activities_with_sql_database(
+    create_fake_dao
+):
     activities = create_fake_dao.get_all()
 
     assert isinstance(activities, typing.List)
     assert activities == []
 
 
-def test_delete__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found_with_sql_database(create_fake_dao, activity_factory, insert_activity):
+def test_delete__returns_an_activity_with_inactive_status__when_an_activity_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, activity_factory, insert_activity
+):
     dao = create_fake_dao
     existent_activity = activity_factory()
     inserted_activity = insert_activity(existent_activity.__dict__, dao)
@@ -101,13 +122,15 @@ def test_delete__returns_an_activity_with_inactive_status__when_an_activity_matc
     assert isinstance(activity, domain.Activity)
     assert activity.id == inserted_activity.id
     assert activity.status == 0
-    assert activity.deleted == True
+    assert activity.deleted is True
 
 
-def test_delete__returns_none__when_no_activity_matching_its_id_is_found_with_sql_database(create_fake_dao, activity_factory):
+def test_delete__returns_none__when_no_activity_matching_its_id_is_found_with_sql_database(
+    create_fake_dao, activity_factory
+):
     dao = create_fake_dao
-    existent_activity = activity_factory()  
+    existent_activity = activity_factory()
 
     results = dao.delete(existent_activity.id)
 
-    assert results == None
+    assert results is None

V2/tests/unit/services/activity_service_test.py

@@ -59,6 +59,7 @@ def test__update_activity__uses_the_activity_dao__to_update_one_activity(
     assert activity_dao.update.called
     assert expected_activity == updated_activity
 
+
 def test__create_activity__uses_the_activity_dao__to_create_an_activity(mocker):
     expected_activity = mocker.Mock()
     activity_dao = mocker.Mock(

V2/tests/unit/use_cases/activities_use_case_test.py

@@ -38,16 +38,17 @@ def test__get_activity_by_id_function__uses_the_activity_service__to_retrieve_ac
 def test__create_activity_function__uses_the_activities_service__to_create_activity(
      mocker: MockFixture,
  ):
-     expected_activity = mocker.Mock()
-     activity_service = mocker.Mock(
+    expected_activity = mocker.Mock()
+    activity_service = mocker.Mock(
          create=mocker.Mock(return_value=expected_activity)
-     )
+    )
 
-     activity_use_case = _use_cases.CreateActivityUseCase(activity_service)
-     actual_activity = activity_use_case.create_activity(fake.pydict())
+    activity_use_case = _use_cases.CreateActivityUseCase(activity_service)
+    actual_activity = activity_use_case.create_activity(fake.pydict())
+
+    assert activity_service.create.called
+    assert expected_activity == actual_activity
 
-     assert activity_service.create.called
-     assert expected_activity == actual_activity
 
 def test__delete_activity_function__uses_the_activity_service__to_change_activity_status(
     mocker: MockFixture,
@@ -63,6 +64,7 @@ def test__delete_activity_function__uses_the_activity_service__to_change_activit
     assert activity_service.delete.called
     assert expected_activity == deleted_activity
 
+
 def test__update_activity_function__uses_the_activities_service__to_update_an_activity(
     mocker: MockFixture,
 ):

V2/time_tracker/_infrastructure/__init__.py

@@ -1,2 +1,3 @@
+# flake8: noqa
 from ._db import DB
-from ._config import Config
+from ._config import Config

V2/time_tracker/_infrastructure/_config.py

@@ -1,6 +1,7 @@
 import typing
 import os
 
+
 class Config(typing.NamedTuple):
     DB_CONNECTION_STRING: str
     DB_USER: str
@@ -9,4 +10,9 @@ class Config(typing.NamedTuple):
 
 
 def load_config():
-    return Config(os.environ.get("DB_CONNECTION_STRING"),os.environ.get("DB_USER"),os.environ.get("DB_PASS"),os.environ.get("DB_NAME"))
+    return Config(
+        os.environ.get("DB_CONNECTION_STRING"),
+        os.environ.get("DB_USER"),
+        os.environ.get("DB_PASS"),
+        os.environ.get("DB_NAME")
+    )

V2/time_tracker/_infrastructure/_db.py

@@ -2,18 +2,19 @@
 
 from . import _config
 
+
 class DB():
     config = _config.load_config()
     connection = None
     engine = None
     conn_string = config.DB_CONNECTION_STRING
     metadata = sqlalchemy.MetaData()
 
-    def __init__(self, conn_string: str = conn_string): 
+    def __init__(self, conn_string: str = conn_string):
         self.engine = sqlalchemy.create_engine(conn_string)
-        
+
     def get_session(self):
-        if self.connection == None:
+        if self.connection is None:
             self.metadata.create_all(self.engine)
             self.connection = self.engine.connect()
-        return self.connection
+        return self.connection

V2/time_tracker/activities/_application/__init__.py

@@ -1,3 +1,4 @@
+# flake8: noqa
 from ._activities import get_activities
 from ._activities import delete_activity
 from ._activities import update_activity

V2/time_tracker/activities/_application/_activities/__init__.py

@@ -1,3 +1,4 @@
+# flake8: noqa
 from ._get_activities import get_activities
 from ._delete_activity import delete_activity
 from ._update_activity import update_activity

V2/time_tracker/activities/_application/_activities/_create_activity.py

@@ -25,7 +25,7 @@ def create_activity(req: func.HttpRequest) -> func.HttpResponse:
         )
 
     activity_to_create = _domain.Activity(
-        id= None,
+        id=None,
         name=activity_data['name'],
         description=activity_data['description'],
         status=activity_data['status'],