feat: TT-243 Refactor code based on PR reviews

tests/time_tracker_api/time_entries/time_entries_query_builder_test.py

@@ -94,10 +94,37 @@ def test_build_with_add_sql_interception_with_date_range_condition():
           OR (c.end_date BETWEEN @start_date AND @end_date))
           OR ((@start_date BETWEEN c.start_date AND c.end_date)
           OR (@end_date BETWEEN c.start_date AND c.end_date)))
+          AND c.start_date!= @end_date
+          AND c.end_date!= @start_date
     """
 
     builder_query = time_entry_query_builder.get_query()
 
     assert remove_white_spaces(builder_query) == remove_white_spaces(
         expected_query
     )
+
+
+def test_add_sql_is_running_time_entry_condition_should_update_where_conditions_list():
+    query_builder = (
+        TimeEntryQueryBuilder().add_sql_is_running_time_entry_condition()
+    )
+
+    assert len(query_builder.where_conditions) == 1
+
+
+@pytest.mark.parametrize(
+    "expected_condition,expected_params",
+    [("c.id!=@ignore_id", {"name": "@ignore_id", "value": "nomatter"})],
+)
+def test_add_sql_ignore_id_condition_should_update_where_conditions_list(
+    expected_condition, expected_params
+):
+    query_builder = TimeEntryQueryBuilder().add_sql_ignore_id_condition(
+        'nomatter'
+    )
+
+    assert len(query_builder.where_conditions) == 1
+    assert len(query_builder.parameters) == 1
+    assert query_builder.where_conditions[0].strip() == expected_condition
+    assert query_builder.parameters[0] == expected_params

tests/utils/query_builder_test.py

@@ -90,88 +90,6 @@ def test_add_sql_where_equal_condition_with_None_should_not_update_lists():
     assert query_builder.parameters == []
 
 
-@pytest.mark.parametrize(
-    "data,expected_where_list,expected_params",
-    [
-        ([], [], []),
-        (
-            [
-                {
-                    "field_name": "end_date",
-                    "compare_field_name": "start_date",
-                    "compare_field_value": "nomatter",
-                },
-                {
-                    "field_name": "start_date",
-                    "compare_field_name": "end_date",
-                    "compare_field_value": "nomatter",
-                },
-            ],
-            [
-                "c.end_date != @start_date",
-                "c.start_date != @end_date",
-            ],
-            [
-                {'name': '@start_date', 'value': 'nomatter'},
-                {'name': '@end_date', 'value': 'nomatter'},
-            ],
-        ),
-    ],
-)
-def test_add_sql_where_not_equal_condition_should_update_where_conditions_list(
-    data, expected_where_list, expected_params
-):
-    query_builder = CosmosDBQueryBuilder().add_sql_where_not_equal_condition(
-        data
-    )
-
-    assert len(query_builder.where_conditions) == len(expected_where_list)
-    assert len(query_builder.parameters) == len(expected_params)
-    assert query_builder.where_conditions == expected_where_list
-    assert query_builder.parameters == expected_params
-
-
-def test_add_sql_where_not_equal_condition_with_none_data_should_not_update_lists():
-    query_builder = CosmosDBQueryBuilder().add_sql_where_not_equal_condition(
-        None
-    )
-
-    assert len(query_builder.where_conditions) == 0
-    assert len(query_builder.parameters) == 0
-    assert query_builder.parameters == []
-    assert query_builder.where_conditions == []
-
-
-@pytest.mark.parametrize(
-    "data,expected_params",
-    [
-        (
-            [
-                {
-                    "field_name": "end_date",
-                    "compare_field_name": "start_date",
-                    "compare_field_value": "nomatter",
-                }
-            ],
-            [
-                {'name': '@start_date', 'value': 'nomatter'},
-            ],
-        )
-    ],
-)
-def test_add_sql_where_not_equal_conditions_should_not_update_parameters_if_already_exists(
-    data, expected_params
-):
-    query_builder = CosmosDBQueryBuilder()
-    query_builder.parameters = [
-        {'name': '@start_date', 'value': 'nomatter'},
-    ]
-
-    query_builder.add_sql_where_not_equal_condition(data)
-
-    assert len(query_builder.parameters) == len(expected_params)
-
-
 @pytest.mark.parametrize(
     "visibility_bool,expected_where_list",
     [(True, ['NOT IS_DEFINED(c.deleted)']), (False, [])],
@@ -413,30 +331,3 @@ def test_add_sql_not_in_condition(
     )
     assert len(query_builder.where_conditions) == len(expected_not_in_list)
     assert query_builder.where_conditions == expected_not_in_list
-
-
-def test_add_sql_non_existent_attribute_condition_should_update_where_conditions_list():
-    query_builder = (
-        CosmosDBQueryBuilder().add_sql_non_existent_attribute_condition('name')
-    )
-    expected_condition = "(NOT IS_DEFINED(c.name) OR c.name = null)"
-
-    assert len(query_builder.where_conditions) == 1
-    assert query_builder.where_conditions[0].strip() == expected_condition
-
-
-@pytest.mark.parametrize(
-    "expected_condition,expected_params",
-    [("c.id!=@ignore_id", {"name": "@ignore_id", "value": "nomatter"})],
-)
-def test_add_sql_ignore_id_condition_should_update_where_conditions_list(
-    expected_condition, expected_params
-):
-    query_builder = CosmosDBQueryBuilder().add_sql_ignore_id_condition(
-        'nomatter'
-    )
-
-    assert len(query_builder.where_conditions) == 1
-    assert len(query_builder.parameters) == 1
-    assert query_builder.where_conditions[0].strip() == expected_condition
-    assert query_builder.parameters[0] == expected_params

time_tracker_api/time_entries/time_entries_query_builder.py

@@ -30,6 +30,8 @@ def add_sql_interception_with_date_range_condition(
           OR (c.end_date BETWEEN @start_date AND @end_date))
           OR ((@start_date BETWEEN c.start_date AND c.end_date)
           OR (@end_date BETWEEN c.start_date AND c.end_date)))
+          AND c.start_date!= @end_date
+          AND c.end_date!= @start_date
         """
         self.where_conditions.append(condition)
         self.parameters.extend(
@@ -39,3 +41,14 @@ def add_sql_interception_with_date_range_condition(
             ]
         )
         return self
+
+    def add_sql_is_running_time_entry_condition(self):
+        condition = "(NOT IS_DEFINED(c.end_date) OR c.end_date = null)"
+        self.where_conditions.append(condition)
+        return self
+
+    def add_sql_ignore_id_condition(self, id: str = None):
+        if id:
+            self.where_conditions.append("c.id!=@ignore_id")
+            self.parameters.append({'name': '@ignore_id', 'value': id})
+        return self

time_tracker_api/time_entries/time_entries_repository.py

@@ -242,25 +242,11 @@ def find_interception_with_date_range(
         }
         end_date = end_date or current_datetime_str()
 
-        not_equal_conditions = [
-            {
-                "field_name": "start_date",
-                "compare_field_name": "end_date",
-                "compare_field_value": end_date,
-            },
-            {
-                "field_name": "end_date",
-                "compare_field_name": "start_date",
-                "compare_field_value": start_date,
-            },
-        ]
-
         query_builder = (
             TimeEntryQueryBuilder()
             .add_sql_interception_with_date_range_condition(
                 start_date, end_date
             )
-            .add_sql_where_not_equal_condition(not_equal_conditions)
             .add_sql_where_equal_condition(conditions)
             .add_sql_ignore_id_condition(ignore_id)
             .add_sql_visibility_condition(visible_only)
@@ -290,7 +276,7 @@ def find_running(
 
         query_builder = (
             TimeEntryQueryBuilder()
-            .add_sql_non_existent_attribute_condition('end_date')
+            .add_sql_is_running_time_entry_condition()
             .add_sql_where_equal_condition(conditions)
             .add_sql_visibility_condition(True)
             .add_sql_offset_condition(0)

utils/query_builder.py

@@ -42,22 +42,6 @@ def add_sql_where_equal_condition(self, data: dict = None):
                 self.parameters.append({'name': f'@{k}', 'value': v})
         return self
 
-    def add_sql_where_not_equal_condition(self, conditions: list = None):
-        if conditions:
-            for condition_values in conditions:
-                field_name = condition_values['field_name']
-                compare_field_name = condition_values['compare_field_name']
-                compare_field_value = condition_values['compare_field_value']
-                condition = f"c.{field_name} != @{compare_field_name}"
-                self.where_conditions.append(condition)
-                parameter = {
-                    'name': f'@{compare_field_name}',
-                    'value': compare_field_value,
-                }
-                if parameter not in self.parameters:
-                    self.parameters.append(parameter)
-        return self
-
     def add_sql_visibility_condition(self, visible_only: bool):
         if visible_only:
             self.where_conditions.append('NOT IS_DEFINED(c.deleted)')
@@ -85,19 +69,6 @@ def add_sql_not_in_condition(
             self.where_conditions.append(f"c.{attribute} NOT IN {ids_values}")
         return self
 
-    def add_sql_non_existent_attribute_condition(self, attribute: str):
-        condition = f"""
-        (NOT IS_DEFINED(c.{attribute}) OR c.{attribute} = null)
-        """
-        self.where_conditions.append(condition)
-        return self
-
-    def add_sql_ignore_id_condition(self, id: str = None):
-        if id:
-            self.where_conditions.append("c.id!=@ignore_id")
-            self.parameters.append({'name': '@ignore_id', 'value': id})
-        return self
-
     def __build_select(self):
         if len(self.select_conditions) < 1:
             self.select_conditions.append("*")