+
+
+@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)