def test___deepcopy__(self): a1 = NestedDict({"k": {"foo": "bar"}}) a2 = copy.deepcopy(a1) self.assertIsNot(a1, a2) self.assertEqual(a1, a2) a1.data["k"]["foo"] = "baz" self.assertNotEqual(a1, a2)
def test_collapse__function_arg__stop_at_root(self): a = NestedDict({"k1": {"k2": {"$foo": {"k3": {"k4": "v"}}}}}) def detect_operator(key, *args): return key == "k1" b = a.collapse(func=detect_operator) self.assertEqual(b, {"k1": {("k2", "$foo", "k3", "k4"): "v"}})
def test___eq____different_class__return_True(self): a1 = NestedDict({"k": {"foo": "bar"}}) a2 = {"k": {"foo": "bar"}} self.assertTrue(a1 == a2) a3 = NestedDict() a4 = {} self.assertTrue(a3 == a4)
def test_collapse__function_arg(self): a = NestedDict({"k1": {"k2": {"$foo": {"k3": {"k4": "v"}}}}}) def detect_operator(key, *args): return key[0] == "$" b = a.collapse(func=detect_operator) self.assertEqual(b, {("k1", "k2"): {"$foo": {("k3", "k4"): "v"}}})
def test_ref__func_arg(self): class CustomClass(NestedDict): def get(self): return {"k2": {"k3": "v"}} def ref_func(haystack, segment, path, i): if isinstance(haystack, CustomClass): return haystack.get() return haystack a = NestedDict({"k1": CustomClass()}) self.assertEqual(a.ref(("k1", "k2", "k3"), func=ref_func), "v")
def test_ref__func_arg__raises_StopIteration(self): class CustomClass(NestedDict): def get(self): return "foo" def ref_func(haystack, segment, path, i): if isinstance(haystack, CustomClass): e = StopIteration() e.haystack = haystack.get() raise e return haystack a = NestedDict({"k1": {"k2": CustomClass()}}) self.assertEqual(a.ref(("k1", "k2", "k3"), func=ref_func), "foo")
def test___bool____return_False(self): self.assertFalse(bool(NestedDict()))
def test_collapse(self): a = NestedDict({"k1": {"k2": {"k3": "v"}}}) b = a.collapse() self.assertEqual(b, {("k1", "k2", "k3"): "v"})
def test___ne____return_False(self): a1 = NestedDict({"k": {"foo": "bar"}}) a2 = NestedDict({"k": {"foo": "bar"}}) self.assertFalse(a1 != a2)
def test___eq____return_False(self): a1 = NestedDict() a2 = None self.assertFalse(a1 == a2)
def test_pull__cleanup_True__removes_empty_containers(self): a = NestedDict({"k": ["v"]}) a.pull("k", "v", cleanup=True) self.assertEqual(a, {})
def test___bool____return_True(self): self.assertTrue(bool(NestedDict({"k": {"k": "v"}})))
def test_unset__string_arg(self): a = NestedDict({"k": "v"}) a.unset("k") self.assertEqual(a, {})
def test_pull__string_arg__raises_TypeError(self): a = NestedDict({"k": "v"}) with self.assertRaises(AttributeError): a.pull("k", "v")
def test_pull__string_arg__raises_ValueError(self): a = NestedDict({"k": []}) with self.assertRaises(ValueError): a.pull("k", "v")
def test___call____instance_of_self_arg(self): a = NestedDict() a(NestedDict({"k": "v"})) self.assertEqual(a, {"k": "v"})
def test_pull__string_arg__raises_KeyError(self): a = NestedDict() with self.assertRaises(KeyError): a.pull("k", "v")
def test_pull__path_arg(self): a = NestedDict({"k1": {"k2": {"k3": ["v"]}}}) a.pull(("k1", "k2", "k3"), "v") self.assertEqual(a, {"k1": {"k2": {"k3": []}}})
def test_unset__cleanup_True__removes_empty_containers(self): a = NestedDict({"k1": {"k2": {"k3": "v"}}}) a.unset(("k1", "k2", "k3"), cleanup=True) self.assertEqual(a, {"k1": {}})
def test___repr__(self): a = NestedDict({"k": {"k": "v"}}) self.assertEqual(repr(a), "NestedDict({'k': NestedDict({'k': 'v'})})")
def test__expand(self): a = NestedDict({"k1": {"k2": {"k3": "v"}}}) b = a._expand(a.collapse()) self.assertEqual(b, a.get())
def test_unset__string_arg__raises_KeyError(self): a = NestedDict({"k": "v"}) with self.assertRaises(KeyError): a.unset("foo")
def test___eq____return_True(self): a1 = NestedDict({"k": {"k": "v"}}) a2 = NestedDict({"k": {"k": "v"}}) self.assertTrue(a1 == a2)
def test_merge__nested_data__nested_data_arg(self): a = NestedDict({"k1": {"k2": "v"}}) b = a.merge({"k1": {"k3": "v"}}) self.assertEqual(b, {"k1": {"k2": "v", "k3": "v"}})
def test___eq____same_class__return_False(self): a1 = NestedDict({"k": {"foo": "bar"}}) a2 = NestedDict({"k": {"bar": "baz"}}) self.assertFalse(a1 == a2)
def test_merge__NestedDict_arg(self): a = NestedDict({"k1": "v"}) b = a.merge(NestedDict({"k2": "v"})) self.assertEqual(b, {"k1": "v", "k2": "v"})
def test___ne____return_True(self): a1 = NestedDict({"k": {"foo": "bar"}}) a2 = NestedDict({"k": {"bar": "baz"}}) self.assertTrue(a1 != a2)
def test_merge__incompatible_types(self): a = NestedDict({"k1": "v"}) b = a.merge("foo") self.assertEqual(b, {"k1": "v"})
def test___str__(self): a = NestedDict({"foo": "bar"}) self.assertEqual(str(a), "{'foo': 'bar'}")
def test_update__NestedDict_arg(self): a = NestedDict({"k1": "v"}) a.update(NestedDict({"k2": "v"})) self.assertEqual(a, {"k1": "v", "k2": "v"})