test: TT-185 add test methods for TimeEntryQueryBuilder and new function in repository

Author: kellycastrof

tests/time_tracker_api/time_entries/time_entries_model_test.py

@@ -269,26 +269,15 @@ def test_updated_item_without_deleted_key_should_call_validate_data(
     time_entry_repository.validate_data.assert_called_once()
 
 
-@pytest.mark.parametrize(
-    'owner_list,expected_result',
-    [
-        ([], ""),
-        (None, ""),
-        (["id"], "AND c.owner_id IN ('id')"),
-        (["id1", "id2"], "AND c.owner_id IN ('id1', 'id2')"),
-    ],
+@patch(
+    'time_tracker_api.time_entries.time_entries_repository.TimeEntryCosmosDBRepository.find_partition_key_value'
+)
+@patch(
+    'time_tracker_api.time_entries.time_entries_repository.TimeEntryCosmosDBRepository.get_page_size_or'
 )
-def test_create_owner_condition(
-    owner_list,
-    expected_result,
-    event_context: EventContext,
-    time_entry_repository: TimeEntryCosmosDBRepository,
-):
-    result = time_entry_repository.create_owner_condition(owner_list)
-    assert result == expected_result
-
-
 def test_find_all_v2(
+    get_page_size_or_mock,
+    find_partition_key_value_mock,
     event_context: EventContext,
     time_entry_repository: TimeEntryCosmosDBRepository,
 ):
@@ -315,9 +304,9 @@ def test_find_all_v2(
         },
     )
 
-    print(result)
+    find_partition_key_value_mock.assert_called_once()
+    get_page_size_or_mock.assert_called_once()
     assert len(result) == 1
     time_entry = result[0]
-    print(time_entry.__dict__)
     assert isinstance(time_entry, TimeEntryCosmosDBModel)
     assert time_entry.__dict__ == expected_item

tests/time_tracker_api/time_entries/time_entries_query_builder_test.py

@@ -0,0 +1,81 @@
+import pytest
+from unittest.mock import patch
+from utils.query_builder import CosmosDBQueryBuilder
+from time_tracker_api.time_entries.time_entries_query_builder import (
+    TimeEntryQueryBuilder,
+)
+from utils.repository import get_string_without_empty_spaces
+
+
+def test_TimeEntryQueryBuilder_is_subclass_CosmosDBQueryBuilder():
+    query_builder = CosmosDBQueryBuilder()
+    time_entries_query_builder = TimeEntryQueryBuilder()
+
+    assert issubclass(TimeEntryQueryBuilder, CosmosDBQueryBuilder) == True
+
+
+@pytest.mark.parametrize(
+    "start_date,end_date,expected_params",
+    [
+        (
+            "2021-03-19T05:07:00.000Z",
+            "2021-03-25T10:00:00.000Z",
+            [
+                {"name": "@start_date", "value": "2021-03-19T05:07:00.000Z"},
+                {"name": "@end_date", "value": "2021-03-25T10:00:00.000Z"},
+            ],
+        ),
+        (
+            "2021-02-10T05:08:00.000Z",
+            "2021-03-20T11:00:00.000Z",
+            [
+                {"name": "@start_date", "value": "2021-02-10T05:08:00.000Z"},
+                {"name": "@end_date", "value": "2021-03-20T11:00:00.000Z"},
+            ],
+        ),
+        (
+            "2021-01-02T05:09:00.000Z",
+            "2021-01-26T12:00:00.000Z",
+            [
+                {"name": "@start_date", "value": "2021-01-02T05:09:00.000Z"},
+                {"name": "@end_date", "value": "2021-01-26T12:00:00.000Z"},
+            ],
+        ),
+    ],
+)
+def test_add_sql_date_range_condition_should_update_where_list(
+    start_date, end_date, expected_params
+):
+    time_entry_query_builder = (
+        TimeEntryQueryBuilder().add_sql_date_range_condition(
+            (start_date, end_date)
+        )
+    )
+
+    assert len(time_entry_query_builder.where_conditions) == 1
+    assert len(time_entry_query_builder.parameters) == len(expected_params)
+    assert time_entry_query_builder.get_parameters() == expected_params
+
+
+def test_build_with_add_sql_date_range_condition():
+    time_entry_query_builder = (
+        TimeEntryQueryBuilder()
+        .add_sql_date_range_condition(
+            ("2021-03-19T05:00:00.000Z", "2021-03-20T10:00:00.000Z")
+        )
+        .build()
+    )
+
+    expected_query = """
+                    SELECT * FROM c
+                    WHERE ((c.start_date BETWEEN @start_date AND @end_date) OR
+                    (c.end_date BETWEEN @start_date AND @end_date))
+                    """
+    query = time_entry_query_builder.get_query()
+
+    assert get_string_without_empty_spaces(
+        query
+    ) == get_string_without_empty_spaces(expected_query)
+
+    assert len(time_entry_query_builder.where_conditions) == 1
+    assert len(time_entry_query_builder.get_parameters()) == 2

tests/utils/query_builder_test.py

@@ -1,5 +1,6 @@
 from unittest.mock import patch
 from utils.query_builder import CosmosDBQueryBuilder
+from utils.repository import get_string_without_empty_spaces
 import pytest
 
 
@@ -178,3 +179,88 @@ def test__build_where_should_return_concatenate_conditions(
     result = query_builder._CosmosDBQueryBuilder__build_where()
 
     assert result == expected_condition
+
+
+@pytest.mark.parametrize(
+    "offset,expected_condition,expected_params",
+    [(1, "OFFSET @offset", [{'name': '@offset', 'value': 1}]), (None, "", [])],
+)
+def test__build_offset(
+    offset,
+    expected_condition,
+    expected_params,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_offset_condition(offset)
+
+    result = query_builder._CosmosDBQueryBuilder__build_offset()
+    assert result == expected_condition
+    assert len(query_builder.parameters) == len(expected_params)
+    assert query_builder.get_parameters() == expected_params
+
+
+@pytest.mark.parametrize(
+    "limit,expected_condition,expected_params",
+    [(1, "LIMIT @limit", [{'name': '@limit', 'value': 1}]), (None, "", [])],
+)
+def test__build_limit(
+    limit,
+    expected_condition,
+    expected_params,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit)
+
+    result = query_builder._CosmosDBQueryBuilder__build_limit()
+    assert result == expected_condition
+    assert len(query_builder.parameters) == len(expected_params)
+    assert query_builder.get_parameters() == expected_params
+
+
+def test_build_with_all_calls_return_query_with_all_conditions():
+    query_builder = (
+        CosmosDBQueryBuilder()
+        .add_select_conditions(["c.description"])
+        .add_sql_in_condition("id", ["id1", "id2"])
+        .add_sql_where_equal_condition({'name': 'test'})
+        .add_sql_offset_condition(2)
+        .add_sql_limit_condition(10)
+        .add_sql_visibility_condition(True)
+        .build()
+    )
+    query = query_builder.get_query()
+    expected_query = """
+                    SELECT c.description FROM c
+                    WHERE c.id IN ('id1', 'id2') AND c.name = @name AND NOT IS_DEFINED(c.deleted)
+                    OFFSET @offset
+                    LIMIT @limit
+                    """
+
+    assert get_string_without_empty_spaces(
+        query
+    ) == get_string_without_empty_spaces(expected_query)
+
+    assert len(query_builder.get_parameters()) > 0
+    assert len(query_builder.where_conditions) > 0
+    assert len(query_builder.select_conditions) > 0
+
+
+def test_build_with_empty_and_None_attributes_return_query_select_all():
+
+    query_builder = (
+        CosmosDBQueryBuilder()
+        .add_select_conditions()
+        .add_sql_in_condition()
+        .add_sql_where_equal_condition()
+        .add_sql_limit_condition(None)
+        .add_sql_offset_condition(None)
+        .build()
+    )
+
+    query = query_builder.get_query()
+
+    expected_query = """SELECT * FROM c"""
+    query = get_string_without_empty_spaces(query)
+    expected_query = get_string_without_empty_spaces(expected_query)
+
+    assert query == expected_query
+    assert len(query_builder.get_parameters()) == 0
+    assert len(query_builder.where_conditions) == 0

tests/utils/repository_test.py

@@ -1,5 +1,8 @@
 from unittest.mock import patch
-from utils.repository import convert_list_to_tuple_string
+from utils.repository import (
+    convert_list_to_tuple_string,
+    get_string_without_empty_spaces,
+)
 import pytest
 
 
@@ -34,3 +37,16 @@ def test_convert_list_to_tuple_string_should_success(
     result = convert_list_to_tuple_string(ids_list)
 
     assert expected_result == result
+
+
+@pytest.mark.parametrize(
+    "string,expected_string",
+    [
+        ("   text with \t tab", "text with tab"),
+        (" text with \n new line", "text with new line"),
+        (""" SELECT * from c             """, "SELECT * from c"),
+    ],
+)
+def test_get_string_without_empty_spaces(string, expected_string):
+    string = get_string_without_empty_spaces(string)
+    assert string == expected_string

utils/repository.py

@@ -7,3 +7,10 @@ def convert_list_to_tuple_string(ids_list):
         else str(tuple(ids_list))
     )
     return result
+
+
+def get_string_without_empty_spaces(string: str):
+    from re import sub
+
+    string = string.replace("\n", "")
+    return sub("[\s]+", ' ', string).rstrip().lstrip()