osm_common/tests/test_dbmemory.py

   1 import http
   2 import logging
   3 import pytest
   4
   5 from unittest.mock import MagicMock
   6 from osm_common.dbbase import DbException
   7 from osm_common.dbmemory import DbMemory
   8
   9 __author__ = 'Eduardo Sousa <eduardosousa@av.it.pt>'
  10
  11
  12 @pytest.fixture
  13 def db_memory():
  14     db = DbMemory()
  15     return db
  16
  17
  18 @pytest.fixture
  19 def db_memory_with_data():
  20     db = DbMemory()
  21
  22     db.create("test", {"_id": 1, "data": 1})
  23     db.create("test", {"_id": 2, "data": 2})
  24     db.create("test", {"_id": 3, "data": 3})
  25
  26     return db
  27
  28
  29 def empty_exception_message():
  30     return 'database exception '
  31
  32
  33 def get_one_exception_message(filter):
  34     return "database exception Not found entry with filter='{}'".format(filter)
  35
  36
  37 def get_one_multiple_exception_message(filter):
  38     return "database exception Found more than one entry with filter='{}'".format(filter)
  39
  40
  41 def del_one_exception_message(filter):
  42     return "database exception Not found entry with filter='{}'".format(filter)
  43
  44
  45 def replace_exception_message(value):
  46     return "database exception Not found entry with _id='{}'".format(value)
  47
  48
  49 def test_constructor():
  50     db = DbMemory()
  51     assert db.logger == logging.getLogger('db')
  52     assert len(db.db) == 0
  53
  54
  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
  60
  61
  62 def test_db_connect():
  63     logger_name = 'db_local'
  64     config = {'logger_name': logger_name}
  65     db = DbMemory()
  66     db.db_connect(config)
  67     assert db.logger == logging.getLogger(logger_name)
  68     assert len(db.db) == 0
  69
  70
  71 def test_db_disconnect(db_memory):
  72     db_memory.db_disconnect()
  73
  74
  75 @pytest.mark.parametrize("table, filter", [
  76     ("test", {}),
  77     ("test", {"_id": 1}),
  78     ("test", {"data": 1}),
  79     ("test", {"_id": 1, "data": 1})])
  80 def test_get_list_with_empty_db(db_memory, table, filter):
  81     result = db_memory.get_list(table, filter)
  82     assert len(result) == 0
  83
  84
  85 @pytest.mark.parametrize("table, 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, filter, expected_data):
 101     result = db_memory_with_data.get_list(table, filter)
 102     assert len(result) == len(expected_data)
 103     for data in expected_data:
 104         assert data in result
 105
 106
 107 def test_get_list_exception(db_memory_with_data):
 108     table = 'test'
 109     filter = {}
 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, filter)
 113     assert str(excinfo.value) == empty_exception_message()
 114     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 115
 116
 117 @pytest.mark.parametrize("table, 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, filter, expected_data):
 128     result = db_memory_with_data.get_one(table, 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]
 134
 135
 136 @pytest.mark.parametrize("table, filter, expected_data", [
 137     ("test", {}, {"_id": 1, "data": 1})])
 138 def test_get_one_with_multiple_results(db_memory_with_data, table, filter, expected_data):
 139     result = db_memory_with_data.get_one(table, 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]
 145
 146
 147 def test_get_one_with_multiple_results_exception(db_memory_with_data):
 148     table = "test"
 149     filter = {}
 150     with pytest.raises(DbException) as excinfo:
 151         db_memory_with_data.get_one(table, filter)
 152     assert str(excinfo.value) == (empty_exception_message() + get_one_multiple_exception_message(filter))
 153     # assert excinfo.value.http_code == http.HTTPStatus.CONFLICT
 154
 155
 156 @pytest.mark.parametrize("table, 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, filter):
 164     with pytest.raises(DbException) as excinfo:
 165         db_memory_with_data.get_one(table, filter)
 166     assert str(excinfo.value) == (empty_exception_message() + get_one_exception_message(filter))
 167     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 168
 169
 170 @pytest.mark.parametrize("table, 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, filter):
 178     result = db_memory_with_data.get_one(table, filter, fail_on_empty=False)
 179     assert result is None
 180
 181
 182 @pytest.mark.parametrize("table, 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, filter):
 190     with pytest.raises(DbException) as excinfo:
 191         db_memory.get_one(table, filter)
 192     assert str(excinfo.value) == (empty_exception_message() + get_one_exception_message(filter))
 193     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 194
 195
 196 @pytest.mark.parametrize("table, 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, filter):
 204     result = db_memory.get_one(table, filter, fail_on_empty=False)
 205     assert result is None
 206
 207
 208 def test_get_one_generic_exception(db_memory_with_data):
 209     table = 'test'
 210     filter = {}
 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, filter)
 214     assert str(excinfo.value) == empty_exception_message()
 215     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 216
 217
 218 @pytest.mark.parametrize("table, filter, expected_data", [
 219     ("test", {}, []),
 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, filter, expected_data):
 225     result = db_memory_with_data.del_list(table, 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]
 232
 233
 234 @pytest.mark.parametrize("table, filter", [
 235     ("test", {}),
 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, filter):
 243     result = db_memory.del_list(table, filter)
 244     assert result['deleted'] == 0
 245
 246
 247 def test_del_list_generic_exception(db_memory_with_data):
 248     table = 'test'
 249     filter = {}
 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, filter)
 253     assert str(excinfo.value) == empty_exception_message()
 254     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 255
 256
 257 @pytest.mark.parametrize("table, 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, filter, data):
 266     result = db_memory_with_data.del_one(table, 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]
 272
 273
 274 @pytest.mark.parametrize("table, filter", [
 275     ("test", {}),
 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}),
 282     ("test_table", {}),
 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, filter):
 290     with pytest.raises(DbException) as excinfo:
 291         db_memory.del_one(table, filter)
 292     assert str(excinfo.value) == (empty_exception_message() + del_one_exception_message(filter))
 293     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 294
 295
 296 @pytest.mark.parametrize("table, filter", [
 297     ("test", {}),
 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}),
 304     ("test_table", {}),
 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, filter):
 312     result = db_memory.del_one(table, filter, fail_on_empty=False)
 313     assert result is None
 314
 315
 316 @pytest.mark.parametrize("table, 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}),
 323     ("test_table", {}),
 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, filter):
 331     with pytest.raises(DbException) as excinfo:
 332         db_memory_with_data.del_one(table, filter)
 333     assert str(excinfo.value) == (empty_exception_message() + del_one_exception_message(filter))
 334     assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND
 335
 336
 337 @pytest.mark.parametrize("table, 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}),
 344     ("test_table", {}),
 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, filter):
 352     result = db_memory_with_data.del_one(table, filter, fail_on_empty=False)
 353     assert result is None
 354
 355
 356 @pytest.mark.parametrize("fail_on_empty", [
 357     (True),
 358     (False)])
 359 def test_del_one_generic_exception(db_memory_with_data, fail_on_empty):
 360     table = 'test'
 361     filter = {}
 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, 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
 367
 368
 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]
 386
 387
 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
 397
 398
 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
 406
 407
 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
 417
 418
 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
 426
 427
 428 @pytest.mark.parametrize("fail_on_empty", [
 429     True,
 430     False])
 431 def test_replace_generic_exception(db_memory_with_data, fail_on_empty):
 432     table = 'test'
 433     _id = {}
 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
 440
 441
 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]
 468
 469
 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]
 496
 497
 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
 520     data_inserted = data
 521     data_inserted['_id'] = returned_id
 522     assert data_inserted in db_memory.db[table]
 523
 524
 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)
 547     data_inserted = data
 548     data_inserted['_id'] = returned_id
 549     assert data_inserted in db_memory_with_data.db[table]
 550
 551
 552 def test_create_with_exception(db_memory):
 553     table = "test"
 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