37c2c837e6b474b7e0f096b9346c2e8f77939821
5 from unittest
.mock
import MagicMock
6 from osm_common
.dbbase
import DbException
7 from osm_common
.dbmemory
import DbMemory
9 __author__
= 'Eduardo Sousa <eduardosousa@av.it.pt>'
12 @pytest.fixture(scope
="function", params
=[True, False])
13 def db_memory(request
):
14 db
= DbMemory(lock
=request
.param
)
18 @pytest.fixture(scope
="function", params
=[True, False])
19 def db_memory_with_data(request
):
20 db
= DbMemory(lock
=request
.param
)
22 db
.create("test", {"_id": 1, "data": 1})
23 db
.create("test", {"_id": 2, "data": 2})
24 db
.create("test", {"_id": 3, "data": 3})
29 def empty_exception_message():
30 return 'database exception '
33 def get_one_exception_message(db_filter
):
34 return "database exception Not found entry with filter='{}'".format(db_filter
)
37 def get_one_multiple_exception_message(db_filter
):
38 return "database exception Found more than one entry with filter='{}'".format(db_filter
)
41 def del_one_exception_message(db_filter
):
42 return "database exception Not found entry with filter='{}'".format(db_filter
)
45 def replace_exception_message(value
):
46 return "database exception Not found entry with _id='{}'".format(value
)
49 def test_constructor():
51 assert db
.logger
== logging
.getLogger('db')
52 assert len(db
.db
) == 0
55 def test_constructor_with_logger():
56 logger_name
= 'db_local'
57 db
= DbMemory(logger_name
=logger_name
)
58 assert db
.logger
== logging
.getLogger(logger_name
)
59 assert len(db
.db
) == 0
62 def test_db_connect():
63 logger_name
= 'db_local'
64 config
= {'logger_name': logger_name
}
67 assert db
.logger
== logging
.getLogger(logger_name
)
68 assert len(db
.db
) == 0
71 def test_db_disconnect(db_memory
):
72 db_memory
.db_disconnect()
75 @pytest.mark
.parametrize("table, db_filter", [
78 ("test", {"data": 1}),
79 ("test", {"_id": 1, "data": 1})])
80 def test_get_list_with_empty_db(db_memory
, table
, db_filter
):
81 result
= db_memory
.get_list(table
, db_filter
)
82 assert len(result
) == 0
85 @pytest.mark
.parametrize("table, db_filter, expected_data", [
86 ("test", {}, [{"_id": 1, "data": 1}, {"_id": 2, "data": 2}, {"_id": 3, "data": 3}]),
87 ("test", {"_id": 1}, [{"_id": 1, "data": 1}]),
88 ("test", {"data": 1}, [{"_id": 1, "data": 1}]),
89 ("test", {"_id": 1, "data": 1}, [{"_id": 1, "data": 1}]),
90 ("test", {"_id": 2}, [{"_id": 2, "data": 2}]),
91 ("test", {"data": 2}, [{"_id": 2, "data": 2}]),
92 ("test", {"_id": 2, "data": 2}, [{"_id": 2, "data": 2}]),
93 ("test", {"_id": 4}, []),
94 ("test", {"data": 4}, []),
95 ("test", {"_id": 4, "data": 4}, []),
96 ("test_table", {}, []),
97 ("test_table", {"_id": 1}, []),
98 ("test_table", {"data": 1}, []),
99 ("test_table", {"_id": 1, "data": 1}, [])])
100 def test_get_list_with_non_empty_db(db_memory_with_data
, table
, db_filter
, expected_data
):
101 result
= db_memory_with_data
.get_list(table
, db_filter
)
102 assert len(result
) == len(expected_data
)
103 for data
in expected_data
:
104 assert data
in result
107 def test_get_list_exception(db_memory_with_data
):
110 db_memory_with_data
._find
= MagicMock(side_effect
=Exception())
111 with pytest
.raises(DbException
) as excinfo
:
112 db_memory_with_data
.get_list(table
, db_filter
)
113 assert str(excinfo
.value
) == empty_exception_message()
114 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
117 @pytest.mark
.parametrize("table, db_filter, expected_data", [
118 ("test", {"_id": 1}, {"_id": 1, "data": 1}),
119 ("test", {"_id": 2}, {"_id": 2, "data": 2}),
120 ("test", {"_id": 3}, {"_id": 3, "data": 3}),
121 ("test", {"data": 1}, {"_id": 1, "data": 1}),
122 ("test", {"data": 2}, {"_id": 2, "data": 2}),
123 ("test", {"data": 3}, {"_id": 3, "data": 3}),
124 ("test", {"_id": 1, "data": 1}, {"_id": 1, "data": 1}),
125 ("test", {"_id": 2, "data": 2}, {"_id": 2, "data": 2}),
126 ("test", {"_id": 3, "data": 3}, {"_id": 3, "data": 3})])
127 def test_get_one(db_memory_with_data
, table
, db_filter
, expected_data
):
128 result
= db_memory_with_data
.get_one(table
, db_filter
)
129 assert result
== expected_data
130 assert len(db_memory_with_data
.db
) == 1
131 assert table
in db_memory_with_data
.db
132 assert len(db_memory_with_data
.db
[table
]) == 3
133 assert result
in db_memory_with_data
.db
[table
]
136 @pytest.mark
.parametrize("table, db_filter, expected_data", [
137 ("test", {}, {"_id": 1, "data": 1})])
138 def test_get_one_with_multiple_results(db_memory_with_data
, table
, db_filter
, expected_data
):
139 result
= db_memory_with_data
.get_one(table
, db_filter
, fail_on_more
=False)
140 assert result
== expected_data
141 assert len(db_memory_with_data
.db
) == 1
142 assert table
in db_memory_with_data
.db
143 assert len(db_memory_with_data
.db
[table
]) == 3
144 assert result
in db_memory_with_data
.db
[table
]
147 def test_get_one_with_multiple_results_exception(db_memory_with_data
):
150 with pytest
.raises(DbException
) as excinfo
:
151 db_memory_with_data
.get_one(table
, db_filter
)
152 assert str(excinfo
.value
) == (empty_exception_message() + get_one_multiple_exception_message(db_filter
))
153 # assert excinfo.value.http_code == http.HTTPStatus.CONFLICT
156 @pytest.mark
.parametrize("table, db_filter", [
157 ("test", {"_id": 4}),
158 ("test", {"data": 4}),
159 ("test", {"_id": 4, "data": 4}),
160 ("test_table", {"_id": 4}),
161 ("test_table", {"data": 4}),
162 ("test_table", {"_id": 4, "data": 4})])
163 def test_get_one_with_non_empty_db_exception(db_memory_with_data
, table
, db_filter
):
164 with pytest
.raises(DbException
) as excinfo
:
165 db_memory_with_data
.get_one(table
, db_filter
)
166 assert str(excinfo
.value
) == (empty_exception_message() + get_one_exception_message(db_filter
))
167 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
170 @pytest.mark
.parametrize("table, db_filter", [
171 ("test", {"_id": 4}),
172 ("test", {"data": 4}),
173 ("test", {"_id": 4, "data": 4}),
174 ("test_table", {"_id": 4}),
175 ("test_table", {"data": 4}),
176 ("test_table", {"_id": 4, "data": 4})])
177 def test_get_one_with_non_empty_db_none(db_memory_with_data
, table
, db_filter
):
178 result
= db_memory_with_data
.get_one(table
, db_filter
, fail_on_empty
=False)
179 assert result
is None
182 @pytest.mark
.parametrize("table, db_filter", [
183 ("test", {"_id": 4}),
184 ("test", {"data": 4}),
185 ("test", {"_id": 4, "data": 4}),
186 ("test_table", {"_id": 4}),
187 ("test_table", {"data": 4}),
188 ("test_table", {"_id": 4, "data": 4})])
189 def test_get_one_with_empty_db_exception(db_memory
, table
, db_filter
):
190 with pytest
.raises(DbException
) as excinfo
:
191 db_memory
.get_one(table
, db_filter
)
192 assert str(excinfo
.value
) == (empty_exception_message() + get_one_exception_message(db_filter
))
193 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
196 @pytest.mark
.parametrize("table, db_filter", [
197 ("test", {"_id": 4}),
198 ("test", {"data": 4}),
199 ("test", {"_id": 4, "data": 4}),
200 ("test_table", {"_id": 4}),
201 ("test_table", {"data": 4}),
202 ("test_table", {"_id": 4, "data": 4})])
203 def test_get_one_with_empty_db_none(db_memory
, table
, db_filter
):
204 result
= db_memory
.get_one(table
, db_filter
, fail_on_empty
=False)
205 assert result
is None
208 def test_get_one_generic_exception(db_memory_with_data
):
211 db_memory_with_data
._find
= MagicMock(side_effect
=Exception())
212 with pytest
.raises(DbException
) as excinfo
:
213 db_memory_with_data
.get_one(table
, db_filter
)
214 assert str(excinfo
.value
) == empty_exception_message()
215 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
218 @pytest.mark
.parametrize("table, db_filter, expected_data", [
220 ("test", {"_id": 1}, [{"_id": 2, "data": 2}, {"_id": 3, "data": 3}]),
221 ("test", {"_id": 2}, [{"_id": 1, "data": 1}, {"_id": 3, "data": 3}]),
222 ("test", {"_id": 1, "data": 1}, [{"_id": 2, "data": 2}, {"_id": 3, "data": 3}]),
223 ("test", {"_id": 2, "data": 2}, [{"_id": 1, "data": 1}, {"_id": 3, "data": 3}])])
224 def test_del_list_with_non_empty_db(db_memory_with_data
, table
, db_filter
, expected_data
):
225 result
= db_memory_with_data
.del_list(table
, db_filter
)
226 assert result
["deleted"] == (3 - len(expected_data
))
227 assert len(db_memory_with_data
.db
) == 1
228 assert table
in db_memory_with_data
.db
229 assert len(db_memory_with_data
.db
[table
]) == len(expected_data
)
230 for data
in expected_data
:
231 assert data
in db_memory_with_data
.db
[table
]
234 @pytest.mark
.parametrize("table, db_filter", [
236 ("test", {"_id": 1}),
237 ("test", {"_id": 2}),
238 ("test", {"data": 1}),
239 ("test", {"data": 2}),
240 ("test", {"_id": 1, "data": 1}),
241 ("test", {"_id": 2, "data": 2})])
242 def test_del_list_with_empty_db(db_memory
, table
, db_filter
):
243 result
= db_memory
.del_list(table
, db_filter
)
244 assert result
['deleted'] == 0
247 def test_del_list_generic_exception(db_memory_with_data
):
250 db_memory_with_data
._find
= MagicMock(side_effect
=Exception())
251 with pytest
.raises(DbException
) as excinfo
:
252 db_memory_with_data
.del_list(table
, db_filter
)
253 assert str(excinfo
.value
) == empty_exception_message()
254 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
257 @pytest.mark
.parametrize("table, db_filter, data", [
258 ("test", {}, {"_id": 1, "data": 1}),
259 ("test", {"_id": 1}, {"_id": 1, "data": 1}),
260 ("test", {"data": 1}, {"_id": 1, "data": 1}),
261 ("test", {"_id": 1, "data": 1}, {"_id": 1, "data": 1}),
262 ("test", {"_id": 2}, {"_id": 2, "data": 2}),
263 ("test", {"data": 2}, {"_id": 2, "data": 2}),
264 ("test", {"_id": 2, "data": 2}, {"_id": 2, "data": 2})])
265 def test_del_one(db_memory_with_data
, table
, db_filter
, data
):
266 result
= db_memory_with_data
.del_one(table
, db_filter
)
267 assert result
== {"deleted": 1}
268 assert len(db_memory_with_data
.db
) == 1
269 assert table
in db_memory_with_data
.db
270 assert len(db_memory_with_data
.db
[table
]) == 2
271 assert data
not in db_memory_with_data
.db
[table
]
274 @pytest.mark
.parametrize("table, db_filter", [
276 ("test", {"_id": 1}),
277 ("test", {"_id": 2}),
278 ("test", {"data": 1}),
279 ("test", {"data": 2}),
280 ("test", {"_id": 1, "data": 1}),
281 ("test", {"_id": 2, "data": 2}),
283 ("test_table", {"_id": 1}),
284 ("test_table", {"_id": 2}),
285 ("test_table", {"data": 1}),
286 ("test_table", {"data": 2}),
287 ("test_table", {"_id": 1, "data": 1}),
288 ("test_table", {"_id": 2, "data": 2})])
289 def test_del_one_with_empty_db_exception(db_memory
, table
, db_filter
):
290 with pytest
.raises(DbException
) as excinfo
:
291 db_memory
.del_one(table
, db_filter
)
292 assert str(excinfo
.value
) == (empty_exception_message() + del_one_exception_message(db_filter
))
293 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
296 @pytest.mark
.parametrize("table, db_filter", [
298 ("test", {"_id": 1}),
299 ("test", {"_id": 2}),
300 ("test", {"data": 1}),
301 ("test", {"data": 2}),
302 ("test", {"_id": 1, "data": 1}),
303 ("test", {"_id": 2, "data": 2}),
305 ("test_table", {"_id": 1}),
306 ("test_table", {"_id": 2}),
307 ("test_table", {"data": 1}),
308 ("test_table", {"data": 2}),
309 ("test_table", {"_id": 1, "data": 1}),
310 ("test_table", {"_id": 2, "data": 2})])
311 def test_del_one_with_empty_db_none(db_memory
, table
, db_filter
):
312 result
= db_memory
.del_one(table
, db_filter
, fail_on_empty
=False)
313 assert result
is None
316 @pytest.mark
.parametrize("table, db_filter", [
317 ("test", {"_id": 4}),
318 ("test", {"_id": 5}),
319 ("test", {"data": 4}),
320 ("test", {"data": 5}),
321 ("test", {"_id": 1, "data": 2}),
322 ("test", {"_id": 2, "data": 3}),
324 ("test_table", {"_id": 1}),
325 ("test_table", {"_id": 2}),
326 ("test_table", {"data": 1}),
327 ("test_table", {"data": 2}),
328 ("test_table", {"_id": 1, "data": 1}),
329 ("test_table", {"_id": 2, "data": 2})])
330 def test_del_one_with_non_empty_db_exception(db_memory_with_data
, table
, db_filter
):
331 with pytest
.raises(DbException
) as excinfo
:
332 db_memory_with_data
.del_one(table
, db_filter
)
333 assert str(excinfo
.value
) == (empty_exception_message() + del_one_exception_message(db_filter
))
334 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
337 @pytest.mark
.parametrize("table, db_filter", [
338 ("test", {"_id": 4}),
339 ("test", {"_id": 5}),
340 ("test", {"data": 4}),
341 ("test", {"data": 5}),
342 ("test", {"_id": 1, "data": 2}),
343 ("test", {"_id": 2, "data": 3}),
345 ("test_table", {"_id": 1}),
346 ("test_table", {"_id": 2}),
347 ("test_table", {"data": 1}),
348 ("test_table", {"data": 2}),
349 ("test_table", {"_id": 1, "data": 1}),
350 ("test_table", {"_id": 2, "data": 2})])
351 def test_del_one_with_non_empty_db_none(db_memory_with_data
, table
, db_filter
):
352 result
= db_memory_with_data
.del_one(table
, db_filter
, fail_on_empty
=False)
353 assert result
is None
356 @pytest.mark
.parametrize("fail_on_empty", [
359 def test_del_one_generic_exception(db_memory_with_data
, fail_on_empty
):
362 db_memory_with_data
._find
= MagicMock(side_effect
=Exception())
363 with pytest
.raises(DbException
) as excinfo
:
364 db_memory_with_data
.del_one(table
, db_filter
, fail_on_empty
=fail_on_empty
)
365 assert str(excinfo
.value
) == empty_exception_message()
366 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
369 @pytest.mark
.parametrize("table, _id, indata", [
370 ("test", 1, {"_id": 1, "data": 42}),
371 ("test", 1, {"_id": 1, "data": 42, "kk": 34}),
372 ("test", 1, {"_id": 1}),
373 ("test", 2, {"_id": 2, "data": 42}),
374 ("test", 2, {"_id": 2, "data": 42, "kk": 34}),
375 ("test", 2, {"_id": 2}),
376 ("test", 3, {"_id": 3, "data": 42}),
377 ("test", 3, {"_id": 3, "data": 42, "kk": 34}),
378 ("test", 3, {"_id": 3})])
379 def test_replace(db_memory_with_data
, table
, _id
, indata
):
380 result
= db_memory_with_data
.replace(table
, _id
, indata
)
381 assert result
== {"updated": 1}
382 assert len(db_memory_with_data
.db
) == 1
383 assert table
in db_memory_with_data
.db
384 assert len(db_memory_with_data
.db
[table
]) == 3
385 assert indata
in db_memory_with_data
.db
[table
]
388 @pytest.mark
.parametrize("table, _id, indata", [
389 ("test", 1, {"_id": 1, "data": 42}),
390 ("test", 2, {"_id": 2}),
391 ("test", 3, {"_id": 3})])
392 def test_replace_without_data_exception(db_memory
, table
, _id
, indata
):
393 with pytest
.raises(DbException
) as excinfo
:
394 db_memory
.replace(table
, _id
, indata
, fail_on_empty
=True)
395 assert str(excinfo
.value
) == (replace_exception_message(_id
))
396 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
399 @pytest.mark
.parametrize("table, _id, indata", [
400 ("test", 1, {"_id": 1, "data": 42}),
401 ("test", 2, {"_id": 2}),
402 ("test", 3, {"_id": 3})])
403 def test_replace_without_data_none(db_memory
, table
, _id
, indata
):
404 result
= db_memory
.replace(table
, _id
, indata
, fail_on_empty
=False)
405 assert result
is None
408 @pytest.mark
.parametrize("table, _id, indata", [
409 ("test", 11, {"_id": 11, "data": 42}),
410 ("test", 12, {"_id": 12}),
411 ("test", 33, {"_id": 33})])
412 def test_replace_with_data_exception(db_memory_with_data
, table
, _id
, indata
):
413 with pytest
.raises(DbException
) as excinfo
:
414 db_memory_with_data
.replace(table
, _id
, indata
, fail_on_empty
=True)
415 assert str(excinfo
.value
) == (replace_exception_message(_id
))
416 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
419 @pytest.mark
.parametrize("table, _id, indata", [
420 ("test", 11, {"_id": 11, "data": 42}),
421 ("test", 12, {"_id": 12}),
422 ("test", 33, {"_id": 33})])
423 def test_replace_with_data_none(db_memory_with_data
, table
, _id
, indata
):
424 result
= db_memory_with_data
.replace(table
, _id
, indata
, fail_on_empty
=False)
425 assert result
is None
428 @pytest.mark
.parametrize("fail_on_empty", [
431 def test_replace_generic_exception(db_memory_with_data
, fail_on_empty
):
434 indata
= {'_id': 1, 'data': 1}
435 db_memory_with_data
._find
= MagicMock(side_effect
=Exception())
436 with pytest
.raises(DbException
) as excinfo
:
437 db_memory_with_data
.replace(table
, _id
, indata
, fail_on_empty
=fail_on_empty
)
438 assert str(excinfo
.value
) == empty_exception_message()
439 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND
442 @pytest.mark
.parametrize("table, id, data", [
443 ("test", "1", {"data": 1}),
444 ("test", "1", {"data": 2}),
445 ("test", "2", {"data": 1}),
446 ("test", "2", {"data": 2}),
447 ("test_table", "1", {"data": 1}),
448 ("test_table", "1", {"data": 2}),
449 ("test_table", "2", {"data": 1}),
450 ("test_table", "2", {"data": 2}),
451 ("test", "1", {"data_1": 1, "data_2": 2}),
452 ("test", "1", {"data_1": 2, "data_2": 1}),
453 ("test", "2", {"data_1": 1, "data_2": 2}),
454 ("test", "2", {"data_1": 2, "data_2": 1}),
455 ("test_table", "1", {"data_1": 1, "data_2": 2}),
456 ("test_table", "1", {"data_1": 2, "data_2": 1}),
457 ("test_table", "2", {"data_1": 1, "data_2": 2}),
458 ("test_table", "2", {"data_1": 2, "data_2": 1})])
459 def test_create_with_empty_db_with_id(db_memory
, table
, id, data
):
460 data_to_insert
= data
461 data_to_insert
['_id'] = id
462 returned_id
= db_memory
.create(table
, data_to_insert
)
463 assert returned_id
== id
464 assert len(db_memory
.db
) == 1
465 assert table
in db_memory
.db
466 assert len(db_memory
.db
[table
]) == 1
467 assert data_to_insert
in db_memory
.db
[table
]
470 @pytest.mark
.parametrize("table, id, data", [
471 ("test", "4", {"data": 1}),
472 ("test", "5", {"data": 2}),
473 ("test", "4", {"data": 1}),
474 ("test", "5", {"data": 2}),
475 ("test_table", "4", {"data": 1}),
476 ("test_table", "5", {"data": 2}),
477 ("test_table", "4", {"data": 1}),
478 ("test_table", "5", {"data": 2}),
479 ("test", "4", {"data_1": 1, "data_2": 2}),
480 ("test", "5", {"data_1": 2, "data_2": 1}),
481 ("test", "4", {"data_1": 1, "data_2": 2}),
482 ("test", "5", {"data_1": 2, "data_2": 1}),
483 ("test_table", "4", {"data_1": 1, "data_2": 2}),
484 ("test_table", "5", {"data_1": 2, "data_2": 1}),
485 ("test_table", "4", {"data_1": 1, "data_2": 2}),
486 ("test_table", "5", {"data_1": 2, "data_2": 1})])
487 def test_create_with_non_empty_db_with_id(db_memory_with_data
, table
, id, data
):
488 data_to_insert
= data
489 data_to_insert
['_id'] = id
490 returned_id
= db_memory_with_data
.create(table
, data_to_insert
)
491 assert returned_id
== id
492 assert len(db_memory_with_data
.db
) == (1 if table
== 'test' else 2)
493 assert table
in db_memory_with_data
.db
494 assert len(db_memory_with_data
.db
[table
]) == (4 if table
== 'test' else 1)
495 assert data_to_insert
in db_memory_with_data
.db
[table
]
498 @pytest.mark
.parametrize("table, data", [
499 ("test", {"data": 1}),
500 ("test", {"data": 2}),
501 ("test", {"data": 1}),
502 ("test", {"data": 2}),
503 ("test_table", {"data": 1}),
504 ("test_table", {"data": 2}),
505 ("test_table", {"data": 1}),
506 ("test_table", {"data": 2}),
507 ("test", {"data_1": 1, "data_2": 2}),
508 ("test", {"data_1": 2, "data_2": 1}),
509 ("test", {"data_1": 1, "data_2": 2}),
510 ("test", {"data_1": 2, "data_2": 1}),
511 ("test_table", {"data_1": 1, "data_2": 2}),
512 ("test_table", {"data_1": 2, "data_2": 1}),
513 ("test_table", {"data_1": 1, "data_2": 2}),
514 ("test_table", {"data_1": 2, "data_2": 1})])
515 def test_create_with_empty_db_without_id(db_memory
, table
, data
):
516 returned_id
= db_memory
.create(table
, data
)
517 assert len(db_memory
.db
) == 1
518 assert table
in db_memory
.db
519 assert len(db_memory
.db
[table
]) == 1
521 data_inserted
['_id'] = returned_id
522 assert data_inserted
in db_memory
.db
[table
]
525 @pytest.mark
.parametrize("table, data", [
526 ("test", {"data": 1}),
527 ("test", {"data": 2}),
528 ("test", {"data": 1}),
529 ("test", {"data": 2}),
530 ("test_table", {"data": 1}),
531 ("test_table", {"data": 2}),
532 ("test_table", {"data": 1}),
533 ("test_table", {"data": 2}),
534 ("test", {"data_1": 1, "data_2": 2}),
535 ("test", {"data_1": 2, "data_2": 1}),
536 ("test", {"data_1": 1, "data_2": 2}),
537 ("test", {"data_1": 2, "data_2": 1}),
538 ("test_table", {"data_1": 1, "data_2": 2}),
539 ("test_table", {"data_1": 2, "data_2": 1}),
540 ("test_table", {"data_1": 1, "data_2": 2}),
541 ("test_table", {"data_1": 2, "data_2": 1})])
542 def test_create_with_non_empty_db_without_id(db_memory_with_data
, table
, data
):
543 returned_id
= db_memory_with_data
.create(table
, data
)
544 assert len(db_memory_with_data
.db
) == (1 if table
== 'test' else 2)
545 assert table
in db_memory_with_data
.db
546 assert len(db_memory_with_data
.db
[table
]) == (4 if table
== 'test' else 1)
548 data_inserted
['_id'] = returned_id
549 assert data_inserted
in db_memory_with_data
.db
[table
]
552 def test_create_with_exception(db_memory
):
554 data
= {"_id": 1, "data": 1}
555 db_memory
.db
= MagicMock()
556 db_memory
.db
.__contains
__.side_effect
= Exception()
557 with pytest
.raises(DbException
) as excinfo
:
558 db_memory
.create(table
, data
)
559 assert str(excinfo
.value
) == empty_exception_message()
560 assert excinfo
.value
.http_code
== http
.HTTPStatus
.NOT_FOUND