+
+
+@pytest.mark.parametrize(
+ "db_content, update_dict, expected, message",
+ [
+ (
+ {"a": {"none": None}},
+ {"a.b.num": "v"},
+ {"a": {"none": None, "b": {"num": "v"}}},
+ "create dict",
+ ),
+ (
+ {"a": {"none": None}},
+ {"a.none.num": "v"},
+ {"a": {"none": {"num": "v"}}},
+ "create dict over none",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b.num": "v"},
+ {"a": {"b": {"num": "v"}}},
+ "replace_number",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b.num.c.d": "v"},
+ None,
+ "create dict over number should fail",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b": "v"},
+ {"a": {"b": "v"}},
+ "replace dict with a string",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b": None},
+ {"a": {"b": None}},
+ "replace dict with None",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.b.num": "v"},
+ None,
+ "create dict over list should fail",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.0.b.num": "v"},
+ {"a": [{"b": {"num": "v"}}]},
+ "set list",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.3.b.num": "v"},
+ {"a": [{"b": {"num": 4}}, None, None, {"b": {"num": "v"}}]},
+ "expand list",
+ ),
+ ({"a": [[4]]}, {"a.0.0": "v"}, {"a": [["v"]]}, "set nested list"),
+ ({"a": [[4]]}, {"a.0.2": "v"}, {"a": [[4, None, "v"]]}, "expand nested list"),
+ (
+ {"a": [[4]]},
+ {"a.2.2": "v"},
+ {"a": [[4], None, {"2": "v"}]},
+ "expand list and add number key",
+ ),
+ ],
+)
+def test_set_one(db_memory, db_content, update_dict, expected, message):
+ db_memory._find = Mock(return_value=((0, db_content),))
+ if expected is None:
+ with pytest.raises(DbException) as excinfo:
+ db_memory.set_one("table", {}, update_dict)
+ assert excinfo.value.http_code == http.HTTPStatus.NOT_FOUND, message
+ else:
+ db_memory.set_one("table", {}, update_dict)
+ assert db_content == expected, message
+
+
+class TestDbMemory(unittest.TestCase):
+ # TODO to delete. This is cover with pytest test_set_one.
+ def test_set_one(self):
+ test_set = (
+ # (database content, set-content, expected database content (None=fails), message)
+ (
+ {"a": {"none": None}},
+ {"a.b.num": "v"},
+ {"a": {"none": None, "b": {"num": "v"}}},
+ "create dict",
+ ),
+ (
+ {"a": {"none": None}},
+ {"a.none.num": "v"},
+ {"a": {"none": {"num": "v"}}},
+ "create dict over none",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b.num": "v"},
+ {"a": {"b": {"num": "v"}}},
+ "replace_number",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b.num.c.d": "v"},
+ None,
+ "create dict over number should fail",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b": "v"},
+ {"a": {"b": "v"}},
+ "replace dict with a string",
+ ),
+ (
+ {"a": {"b": {"num": 4}}},
+ {"a.b": None},
+ {"a": {"b": None}},
+ "replace dict with None",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.b.num": "v"},
+ None,
+ "create dict over list should fail",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.0.b.num": "v"},
+ {"a": [{"b": {"num": "v"}}]},
+ "set list",
+ ),
+ (
+ {"a": [{"b": {"num": 4}}]},
+ {"a.3.b.num": "v"},
+ {"a": [{"b": {"num": 4}}, None, None, {"b": {"num": "v"}}]},
+ "expand list",
+ ),
+ ({"a": [[4]]}, {"a.0.0": "v"}, {"a": [["v"]]}, "set nested list"),
+ (
+ {"a": [[4]]},
+ {"a.0.2": "v"},
+ {"a": [[4, None, "v"]]},
+ "expand nested list",
+ ),
+ (
+ {"a": [[4]]},
+ {"a.2.2": "v"},
+ {"a": [[4], None, {"2": "v"}]},
+ "expand list and add number key",
+ ),
+ ({"a": None}, {"b.c": "v"}, {"a": None, "b": {"c": "v"}}, "expand at root"),
+ )
+ db_men = DbMemory()
+ db_men._find = Mock()
+ for db_content, update_dict, expected, message in test_set:
+ db_men._find.return_value = ((0, db_content),)
+ if expected is None:
+ self.assertRaises(DbException, db_men.set_one, "table", {}, update_dict)
+ else:
+ db_men.set_one("table", {}, update_dict)
+ self.assertEqual(db_content, expected, message)
+
+ def test_set_one_pull(self):
+ example = {"a": [1, "1", 1], "d": {}, "n": None}
+ test_set = (
+ # (database content, set-content, expected database content (None=fails), message)
+ (example, {"a": "1"}, {"a": [1, 1], "d": {}, "n": None}, "pull one item"),
+ (example, {"a": 1}, {"a": ["1"], "d": {}, "n": None}, "pull two items"),
+ (example, {"a": "v"}, example, "pull non existing item"),
+ (example, {"a.6": 1}, example, "pull non existing arrray"),
+ (example, {"d.b.c": 1}, example, "pull non existing arrray2"),
+ (example, {"b": 1}, example, "pull non existing arrray3"),
+ (example, {"d": 1}, None, "pull over dict"),
+ (example, {"n": 1}, None, "pull over None"),
+ )
+ db_men = DbMemory()
+ db_men._find = Mock()
+ for db_content, pull_dict, expected, message in test_set:
+ db_content = deepcopy(db_content)
+ db_men._find.return_value = ((0, db_content),)
+ if expected is None:
+ self.assertRaises(
+ DbException,
+ db_men.set_one,
+ "table",
+ {},
+ None,
+ fail_on_empty=False,
+ pull=pull_dict,
+ )
+ else:
+ db_men.set_one("table", {}, None, pull=pull_dict)
+ self.assertEqual(db_content, expected, message)
+
+ def test_set_one_push(self):
+ example = {"a": [1, "1", 1], "d": {}, "n": None}
+ test_set = (
+ # (database content, set-content, expected database content (None=fails), message)
+ (
+ example,
+ {"d.b.c": 1},
+ {"a": [1, "1", 1], "d": {"b": {"c": [1]}}, "n": None},
+ "push non existing arrray2",
+ ),
+ (
+ example,
+ {"b": 1},
+ {"a": [1, "1", 1], "d": {}, "b": [1], "n": None},
+ "push non existing arrray3",
+ ),
+ (
+ example,
+ {"a.6": 1},
+ {"a": [1, "1", 1, None, None, None, [1]], "d": {}, "n": None},
+ "push non existing arrray",
+ ),
+ (
+ example,
+ {"a": 2},
+ {"a": [1, "1", 1, 2], "d": {}, "n": None},
+ "push one item",
+ ),
+ (
+ example,
+ {"a": {1: 1}},
+ {"a": [1, "1", 1, {1: 1}], "d": {}, "n": None},
+ "push a dict",
+ ),
+ (example, {"d": 1}, None, "push over dict"),
+ (example, {"n": 1}, None, "push over None"),
+ )
+ db_men = DbMemory()
+ db_men._find = Mock()
+ for db_content, push_dict, expected, message in test_set:
+ db_content = deepcopy(db_content)
+ db_men._find.return_value = ((0, db_content),)
+ if expected is None:
+ self.assertRaises(
+ DbException,
+ db_men.set_one,
+ "table",
+ {},
+ None,
+ fail_on_empty=False,
+ push=push_dict,
+ )
+ else:
+ db_men.set_one("table", {}, None, push=push_dict)
+ self.assertEqual(db_content, expected, message)
+
+ def test_set_one_push_list(self):
+ example = {"a": [1, "1", 1], "d": {}, "n": None}
+ test_set = (
+ # (database content, set-content, expected database content (None=fails), message)
+ (
+ example,
+ {"d.b.c": [1]},
+ {"a": [1, "1", 1], "d": {"b": {"c": [1]}}, "n": None},
+ "push non existing arrray2",
+ ),
+ (
+ example,
+ {"b": [1]},
+ {"a": [1, "1", 1], "d": {}, "b": [1], "n": None},
+ "push non existing arrray3",
+ ),
+ (
+ example,
+ {"a.6": [1]},
+ {"a": [1, "1", 1, None, None, None, [1]], "d": {}, "n": None},
+ "push non existing arrray",
+ ),
+ (
+ example,
+ {"a": [2, 3]},
+ {"a": [1, "1", 1, 2, 3], "d": {}, "n": None},
+ "push two item",
+ ),
+ (
+ example,
+ {"a": [{1: 1}]},
+ {"a": [1, "1", 1, {1: 1}], "d": {}, "n": None},
+ "push a dict",
+ ),
+ (example, {"d": [1]}, None, "push over dict"),
+ (example, {"n": [1]}, None, "push over None"),
+ (example, {"a": 1}, None, "invalid push list non an array"),
+ )
+ db_men = DbMemory()
+ db_men._find = Mock()
+ for db_content, push_list, expected, message in test_set:
+ db_content = deepcopy(db_content)
+ db_men._find.return_value = ((0, db_content),)
+ if expected is None:
+ self.assertRaises(
+ DbException,
+ db_men.set_one,
+ "table",
+ {},
+ None,
+ fail_on_empty=False,
+ push_list=push_list,
+ )
+ else:
+ db_men.set_one("table", {}, None, push_list=push_list)
+ self.assertEqual(db_content, expected, message)
+
+ def test_unset_one(self):
+ example = {"a": [1, "1", 1], "d": {}, "n": None}
+ test_set = (
+ # (database content, set-content, expected database content (None=fails), message)
+ (example, {"d.b.c": 1}, example, "unset non existing"),
+ (example, {"b": 1}, example, "unset non existing"),
+ (example, {"a.6": 1}, example, "unset non existing arrray"),
+ (example, {"a": 2}, {"d": {}, "n": None}, "unset array"),
+ (example, {"d": 1}, {"a": [1, "1", 1], "n": None}, "unset dict"),
+ (example, {"n": 1}, {"a": [1, "1", 1], "d": {}}, "unset None"),
+ )
+ db_men = DbMemory()
+ db_men._find = Mock()
+ for db_content, unset_dict, expected, message in test_set:
+ db_content = deepcopy(db_content)
+ db_men._find.return_value = ((0, db_content),)
+ if expected is None:
+ self.assertRaises(
+ DbException,
+ db_men.set_one,
+ "table",
+ {},
+ None,
+ fail_on_empty=False,
+ unset=unset_dict,
+ )
+ else:
+ db_men.set_one("table", {}, None, unset=unset_dict)
+ self.assertEqual(db_content, expected, message)