feat: TT-243 Add functions and testing to base query builder

tests/utils/query_builder_test.py

@@ -90,6 +90,88 @@ 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, [])],
@@ -331,3 +413,30 @@ 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

utils/query_builder.py

@@ -42,6 +42,22 @@ 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)')
@@ -69,6 +85,19 @@ 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("*")