|
| 1 | +from unittest.mock import patch |
| 2 | +from utils.query_builder import CosmosDBQueryBuilder |
| 3 | +from utils.repository import remove_white_spaces |
| 4 | +import pytest |
| 5 | + |
| 6 | + |
| 7 | +@pytest.mark.parametrize( |
| 8 | + "condition_list, expected_select_condition", |
| 9 | + [ |
| 10 | + (None, ["*"]), |
| 11 | + ([], ["*"]), |
| 12 | + (["*"], ["*"]), |
| 13 | + (["c.id"], ["c.id"]), |
| 14 | + (["c.id", "c.name"], ["c.id", "c.name"]), |
| 15 | + ], |
| 16 | +) |
| 17 | +def test_add_select_conditions_should_update_select_list( |
| 18 | + condition_list, expected_select_condition |
| 19 | +): |
| 20 | + query_builder = CosmosDBQueryBuilder().add_select_conditions( |
| 21 | + condition_list |
| 22 | + ) |
| 23 | + |
| 24 | + assert len(query_builder.select_conditions) == len( |
| 25 | + expected_select_condition |
| 26 | + ) |
| 27 | + assert query_builder.select_conditions == expected_select_condition |
| 28 | + |
| 29 | + |
| 30 | +@pytest.mark.parametrize( |
| 31 | + "attribute,ids_list,expected_where_condition_list", |
| 32 | + [ |
| 33 | + ("id", [], []), |
| 34 | + (None, None, []), |
| 35 | + ("id", None, []), |
| 36 | + (None, ["id"], []), |
| 37 | + ("id", ["id"], ["c.id IN ('id')"]), |
| 38 | + ("id", ["id1", "id2"], ["c.id IN ('id1', 'id2')"]), |
| 39 | + ("owner_id", ["id1", "id2"], ["c.owner_id IN ('id1', 'id2')"]), |
| 40 | + ("customer_id", ["id1", "id2"], ["c.customer_id IN ('id1', 'id2')"]), |
| 41 | + ], |
| 42 | +) |
| 43 | +def test_add_sql_in_condition_should_update_where_list( |
| 44 | + attribute, ids_list, expected_where_condition_list, |
| 45 | +): |
| 46 | + query_builder = CosmosDBQueryBuilder().add_sql_in_condition( |
| 47 | + attribute, ids_list |
| 48 | + ) |
| 49 | + |
| 50 | + assert len(query_builder.where_conditions) == len( |
| 51 | + expected_where_condition_list |
| 52 | + ) |
| 53 | + assert query_builder.where_conditions == expected_where_condition_list |
| 54 | + |
| 55 | + |
| 56 | +@pytest.mark.parametrize( |
| 57 | + "data,expected_where_list,expected_params", |
| 58 | + [ |
| 59 | + ({}, [], []), |
| 60 | + ({'id': 1}, ["c.id = @id"], [{'name': "@id", 'value': 1}]), |
| 61 | + ( |
| 62 | + {'id': 1, 'name': 'test'}, |
| 63 | + ["c.id = @id", "c.name = @name"], |
| 64 | + [{'name': "@id", 'value': 1}, {'name': "@name", 'value': 'test'}], |
| 65 | + ), |
| 66 | + ], |
| 67 | +) |
| 68 | +def test_add_sql_where_equal_condition_should_update_where_params_list( |
| 69 | + data, expected_where_list, expected_params, |
| 70 | +): |
| 71 | + query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(data) |
| 72 | + |
| 73 | + assert len(query_builder.where_conditions) == len(data) |
| 74 | + assert query_builder.where_conditions == expected_where_list |
| 75 | + |
| 76 | + assert len(query_builder.parameters) == len(expected_params) |
| 77 | + assert query_builder.parameters == expected_params |
| 78 | + |
| 79 | + |
| 80 | +def test_add_sql_where_equal_condition_with_None_should_not_update_lists(): |
| 81 | + query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition(None) |
| 82 | + |
| 83 | + assert len(query_builder.where_conditions) == 0 |
| 84 | + assert query_builder.where_conditions == [] |
| 85 | + assert len(query_builder.parameters) == 0 |
| 86 | + assert query_builder.parameters == [] |
| 87 | + |
| 88 | + |
| 89 | +@pytest.mark.parametrize( |
| 90 | + "visibility_bool,expected_where_list", |
| 91 | + [(True, ['NOT IS_DEFINED(c.deleted)']), (False, [])], |
| 92 | +) |
| 93 | +def test_add_sql_visibility_condition( |
| 94 | + visibility_bool, expected_where_list, |
| 95 | +): |
| 96 | + query_builder = CosmosDBQueryBuilder().add_sql_visibility_condition( |
| 97 | + visibility_bool |
| 98 | + ) |
| 99 | + |
| 100 | + assert len(query_builder.where_conditions) == len(expected_where_list) |
| 101 | + assert query_builder.where_conditions == expected_where_list |
| 102 | + |
| 103 | + |
| 104 | +@pytest.mark.parametrize( |
| 105 | + "limit_value,expected_limit", [(1, 1), (10, 10), (None, None),], |
| 106 | +) |
| 107 | +def test_add_sql_limit_condition(limit_value, expected_limit): |
| 108 | + query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit_value) |
| 109 | + |
| 110 | + assert query_builder.limit == expected_limit |
| 111 | + |
| 112 | + |
| 113 | +@pytest.mark.parametrize( |
| 114 | + "offset_value,expected_offset", [(1, 1), (10, 10), (None, None),], |
| 115 | +) |
| 116 | +def test_add_sql_offset_condition( |
| 117 | + offset_value, expected_offset, |
| 118 | +): |
| 119 | + query_builder = CosmosDBQueryBuilder().add_sql_offset_condition( |
| 120 | + offset_value |
| 121 | + ) |
| 122 | + |
| 123 | + assert query_builder.offset == expected_offset |
| 124 | + |
| 125 | + |
| 126 | +@pytest.mark.parametrize( |
| 127 | + "select_conditions,expected_condition", |
| 128 | + [([], "*"), (["c.id"], "c.id"), (["c.id", "c.name"], "c.id,c.name"),], |
| 129 | +) |
| 130 | +def test__build_select_return_fields_in_select_list( |
| 131 | + select_conditions, expected_condition, |
| 132 | +): |
| 133 | + query_builder = CosmosDBQueryBuilder().add_select_conditions( |
| 134 | + select_conditions |
| 135 | + ) |
| 136 | + |
| 137 | + result = query_builder._CosmosDBQueryBuilder__build_select() |
| 138 | + assert result == expected_condition |
| 139 | + |
| 140 | + |
| 141 | +@pytest.mark.parametrize( |
| 142 | + "fields,expected_condition", |
| 143 | + [ |
| 144 | + (None, ""), |
| 145 | + ({}, ""), |
| 146 | + ({"id": 1}, "WHERE c.id = @id"), |
| 147 | + ({"id": 1, "name": "test"}, "WHERE c.id = @id AND c.name = @name"), |
| 148 | + ], |
| 149 | +) |
| 150 | +def test__build_where_should_return_concatenated_conditions( |
| 151 | + fields, expected_condition, |
| 152 | +): |
| 153 | + query_builder = CosmosDBQueryBuilder().add_sql_where_equal_condition( |
| 154 | + fields |
| 155 | + ) |
| 156 | + |
| 157 | + result = query_builder._CosmosDBQueryBuilder__build_where() |
| 158 | + |
| 159 | + assert result == expected_condition |
| 160 | + |
| 161 | + |
| 162 | +@pytest.mark.parametrize( |
| 163 | + "offset,expected_condition,expected_params", |
| 164 | + [(1, "OFFSET @offset", [{'name': '@offset', 'value': 1}]), (None, "", [])], |
| 165 | +) |
| 166 | +def test__build_offset( |
| 167 | + offset, expected_condition, expected_params, |
| 168 | +): |
| 169 | + query_builder = CosmosDBQueryBuilder().add_sql_offset_condition(offset) |
| 170 | + |
| 171 | + result = query_builder._CosmosDBQueryBuilder__build_offset() |
| 172 | + assert result == expected_condition |
| 173 | + assert len(query_builder.parameters) == len(expected_params) |
| 174 | + assert query_builder.get_parameters() == expected_params |
| 175 | + |
| 176 | + |
| 177 | +@pytest.mark.parametrize( |
| 178 | + "limit,expected_condition,expected_params", |
| 179 | + [(1, "LIMIT @limit", [{'name': '@limit', 'value': 1}]), (None, "", [])], |
| 180 | +) |
| 181 | +def test__build_limit( |
| 182 | + limit, expected_condition, expected_params, |
| 183 | +): |
| 184 | + query_builder = CosmosDBQueryBuilder().add_sql_limit_condition(limit) |
| 185 | + |
| 186 | + result = query_builder._CosmosDBQueryBuilder__build_limit() |
| 187 | + assert result == expected_condition |
| 188 | + assert len(query_builder.parameters) == len(expected_params) |
| 189 | + assert query_builder.get_parameters() == expected_params |
| 190 | + |
| 191 | + |
| 192 | +def test_build_with_all_calls_return_query_with_all_conditions(): |
| 193 | + query_builder = ( |
| 194 | + CosmosDBQueryBuilder() |
| 195 | + .add_select_conditions(["c.description"]) |
| 196 | + .add_sql_in_condition("id", ["id1", "id2"]) |
| 197 | + .add_sql_where_equal_condition({'name': 'test'}) |
| 198 | + .add_sql_offset_condition(2) |
| 199 | + .add_sql_limit_condition(10) |
| 200 | + .add_sql_visibility_condition(True) |
| 201 | + .build() |
| 202 | + ) |
| 203 | + query = query_builder.get_query() |
| 204 | + expected_query = """ |
| 205 | + SELECT c.description FROM c |
| 206 | + WHERE c.id IN ('id1', 'id2') AND c.name = @name AND NOT IS_DEFINED(c.deleted) |
| 207 | + OFFSET @offset |
| 208 | + LIMIT @limit |
| 209 | + """ |
| 210 | + |
| 211 | + assert remove_white_spaces(query) == remove_white_spaces(expected_query) |
| 212 | + assert len(query_builder.get_parameters()) > 0 |
| 213 | + assert len(query_builder.where_conditions) > 0 |
| 214 | + assert len(query_builder.select_conditions) > 0 |
| 215 | + |
| 216 | + |
| 217 | +def test_build_with_empty_and_None_attributes_return_query_select_all(): |
| 218 | + |
| 219 | + query_builder = ( |
| 220 | + CosmosDBQueryBuilder() |
| 221 | + .add_select_conditions() |
| 222 | + .add_sql_in_condition() |
| 223 | + .add_sql_where_equal_condition() |
| 224 | + .add_sql_limit_condition(None) |
| 225 | + .add_sql_offset_condition(None) |
| 226 | + .build() |
| 227 | + ) |
| 228 | + |
| 229 | + query = query_builder.get_query() |
| 230 | + expected_query = """SELECT * FROM c""" |
| 231 | + |
| 232 | + query = remove_white_spaces(query) |
| 233 | + expected_query = remove_white_spaces(expected_query) |
| 234 | + |
| 235 | + assert query == expected_query |
| 236 | + assert len(query_builder.get_parameters()) == 0 |
| 237 | + assert len(query_builder.where_conditions) == 0 |
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4&size=40){kind=avatar}
0 commit comments