Tt 185 find all method in time entries

requirements/time_tracker_api/prod.txt

@@ -12,7 +12,7 @@ Flask==1.1.1
 flake8==3.7.9
 WSGIserver==1.3
 Werkzeug==0.16.1
-Jinja2==2.11.1
+Jinja2==2.11.3
 
 #WSGI server
 gunicorn==20.0.4

tests/time_tracker_api/time_entries/time_entries_model_test.py

@@ -8,6 +8,7 @@
 )
 from time_tracker_api.time_entries.time_entries_repository import (
     TimeEntryCosmosDBRepository,
+    TimeEntryCosmosDBModel,
 )
 
 
@@ -266,3 +267,46 @@ def test_updated_item_without_deleted_key_should_call_validate_data(
     time_entry_repository.on_update({}, event_context)
     on_update_mock.assert_called_once()
     time_entry_repository.validate_data.assert_called_once()
+
+
+@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_find_all_v2(
+    get_page_size_or_mock,
+    find_partition_key_value_mock,
+    event_context: EventContext,
+    time_entry_repository: TimeEntryCosmosDBRepository,
+):
+    expected_item = {
+        'id': 'id',
+        'start_date': '2021-03-22T10:00:00.000Z',
+        'end_date': "2021-03-22T11:00:00.000Z",
+        'description': 'do some testing',
+        'tenant_id': 'tenant_id',
+        'project_id': 'project_id',
+        'activity_id': 'activity_id',
+        'technologies': ['python'],
+    }
+    query_items_mock = Mock(return_value=[expected_item])
+    time_entry_repository.container = Mock()
+    time_entry_repository.container.query_items = query_items_mock
+
+    result = time_entry_repository.find_all_v2(
+        event_context,
+        ['owner_id'],
+        {
+            'start_date': "2021-03-22T10:00:00.000Z",
+            'end_date': "2021-03-22T11:00:00.000Z",
+        },
+    )
+
+    find_partition_key_value_mock.assert_called_once()
+    get_page_size_or_mock.assert_called_once()
+    assert len(result) == 1
+    time_entry = result[0]
+    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,51 @@
+import pytest
+from utils.query_builder import CosmosDBQueryBuilder
+from time_tracker_api.time_entries.time_entries_query_builder import (
+    TimeEntryQueryBuilder,
+)
+from utils.repository import remove_white_spaces
+
+
+def test_TimeEntryQueryBuilder_is_subclass_CosmosDBQueryBuilder():
+    query_builder = CosmosDBQueryBuilder()
+    time_entries_query_builder = TimeEntryQueryBuilder()
+
+    assert issubclass(
+        time_entries_query_builder.__class__, query_builder.__class__
+    )
+
+
+def test_add_sql_date_range_condition_should_update_where_list():
+    time_entry_query_builder = (
+        TimeEntryQueryBuilder().add_sql_date_range_condition(
+            ("2021-03-19T05:07:00.000Z", "2021-03-25T10:00:00.000Z")
+        )
+    )
+    expected_params = [
+        {"name": "@start_date", "value": "2021-03-19T05:07:00.000Z"},
+        {"name": "@end_date", "value": "2021-03-25T10:00:00.000Z"},
+    ]
+    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 remove_white_spaces(query) == remove_white_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

@@ -0,0 +1,237 @@
+from unittest.mock import patch
+from utils.query_builder import CosmosDBQueryBuilder
+from utils.repository import remove_white_spaces
+import pytest
+
+
+@pytest.mark.parametrize(
+    "condition_list, expected_select_condition",
+    [
+        (None, ["*"]),
+        ([], ["*"]),
+        (["*"], ["*"]),
+        (["c.id"], ["c.id"]),
+        (["c.id", "c.name"], ["c.id", "c.name"]),
+    ],
+)
+def test_add_select_conditions_should_update_select_list(
+    condition_list, expected_select_condition
+):
+    query_builder = CosmosDBQueryBuilder().add_select_conditions(
+        condition_list
+    )
+
+    assert len(query_builder.select_conditions) == len(
+        expected_select_condition
+    )
+    assert query_builder.select_conditions == expected_select_condition
+
+
+@pytest.mark.parametrize(
+    "attribute,ids_list,expected_where_condition_list",
+    [
+        ("id", [], []),
+        (None, None, []),
+        ("id", None, []),
+        (None, ["id"], []),
+        ("id", ["id"], ["c.id IN ('id')"]),
+        ("id", ["id1", "id2"], ["c.id IN ('id1', 'id2')"]),
+        ("owner_id", ["id1", "id2"], ["c.owner_id IN ('id1', 'id2')"]),
+        ("customer_id", ["id1", "id2"], ["c.customer_id IN ('id1', 'id2')"]),
+    ],
+)
+def test_add_sql_in_condition_should_update_where_list(
+    attribute, ids_list, expected_where_condition_list,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_in_condition(
+        attribute, ids_list
+    )
+
+    assert len(query_builder.where_conditions) == len(
+        expected_where_condition_list
+    )
+    assert query_builder.where_conditions == expected_where_condition_list
+
+
+@pytest.mark.parametrize(
+    "data,expected_where_list,expected_params",
+    [
+        ({}, [], []),
+        ({'id': 1}, ["c.id = @id"], [{'name': "@id", 'value': 1}]),
+        (
+            {'id': 1, 'name': 'test'},
+            ["c.id = @id", "c.name = @name"],
+            [{'name': "@id", 'value': 1}, {'name': "@name", 'value': 'test'}],
+        ),
+    ],
+)
+def test_add_sql_where_equal_condition_should_update_where_params_list(
+    data, expected_where_list, expected_params,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(data)
+
+    assert len(query_builder.where_conditions) == len(data)
+    assert query_builder.where_conditions == expected_where_list
+
+    assert len(query_builder.parameters) == len(expected_params)
+    assert query_builder.parameters == expected_params
+
+
+def test_add_sql_where_equal_condition_with_None_should_not_update_lists():
+    query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(None)
+
+    assert len(query_builder.where_conditions) == 0
+    assert query_builder.where_conditions == []
+    assert len(query_builder.parameters) == 0
+    assert query_builder.parameters == []
+
+
+@pytest.mark.parametrize(
+    "visibility_bool,expected_where_list",
+    [(True, ['NOT IS_DEFINED(c.deleted)']), (False, [])],
+)
+def test_add_sql_visibility_condition(
+    visibility_bool, expected_where_list,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_visibility_condition(
+        visibility_bool
+    )
+
+    assert len(query_builder.where_conditions) == len(expected_where_list)
+    assert query_builder.where_conditions == expected_where_list
+
+
+@pytest.mark.parametrize(
+    "limit_value,expected_limit", [(1, 1), (10, 10), (None, None),],
+)
+def test_add_sql_limit_condition(limit_value, expected_limit):
+    query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit_value)
+
+    assert query_builder.limit == expected_limit
+
+
+@pytest.mark.parametrize(
+    "offset_value,expected_offset", [(1, 1), (10, 10), (None, None),],
+)
+def test_add_sql_offset_condition(
+    offset_value, expected_offset,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_offset_condition(
+        offset_value
+    )
+
+    assert query_builder.offset == expected_offset
+
+
+@pytest.mark.parametrize(
+    "select_conditions,expected_condition",
+    [([], "*"), (["c.id"], "c.id"), (["c.id", "c.name"], "c.id,c.name"),],
+)
+def test__build_select_return_fields_in_select_list(
+    select_conditions, expected_condition,
+):
+    query_builder = CosmosDBQueryBuilder().add_select_conditions(
+        select_conditions
+    )
+
+    result = query_builder._CosmosDBQueryBuilder__build_select()
+    assert result == expected_condition
+
+
+@pytest.mark.parametrize(
+    "fields,expected_condition",
+    [
+        (None, ""),
+        ({}, ""),
+        ({"id": 1}, "WHERE c.id = @id"),
+        ({"id": 1, "name": "test"}, "WHERE c.id = @id AND c.name = @name"),
+    ],
+)
+def test__build_where_should_return_concatenated_conditions(
+    fields, expected_condition,
+):
+    query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(
+        fields
+    )
+
+    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 remove_white_spaces(query) == remove_white_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 = remove_white_spaces(query)
+    expected_query = remove_white_spaces(expected_query)
+
+    assert query == expected_query
+    assert len(query_builder.get_parameters()) == 0
+    assert len(query_builder.where_conditions) == 0