def test_pop_with_1_valid_key(self):
d = {
'a': 1,
}
b = KeypathDict(d)
val = b.pop('a')
self.assertEqual(val, 1)
def test_pop_with_wrong_index(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
b.pop('a[5]')
def test_delitem_with_3_valid_keys(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
}
}
b = KeypathDict(d)
del b['a.b.c']
with self.assertRaises(KeyError):
del b['a.b.c']
self.assertEqual(b.get('a.b'), {'d': 2})
del b['a.b.d']
with self.assertRaises(KeyError):
del b['a.b.d']
self.assertEqual(b.get('a.b'), {})
del b['a.b']
with self.assertRaises(KeyError):
del b['a.b']
self.assertEqual(b.get('a.b'), None)
def test_delitem_with_1_invalid_key(self):
d = {
'a': 1,
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
del b['b']
self.assertEqual(b.get('b'), None)
def test_pop_with_flat_list_and_default(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
b.pop('a[3]')
self.assertEqual(b.pop('a[3]', 4), 4)
def test_pop_with_flat_list(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
self.assertEqual(b.pop('a[-1]'), 3)
self.assertEqual(b.pop('a[0]'), 1)
self.assertEqual(b.pop('a'), [2])
def test_delitem_with_2_invalid_keys(self):
d = {
'a': {
'b': 1,
}
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
del b['a.c']
self.assertEqual(b.get('a'), {'b': 1})
def test_pop_default(self):
d = {
'a': 1,
}
b = KeypathDict(d)
val = b.pop('a', 2)
self.assertEqual(val, 1)
val = b.pop('b', 2)
self.assertEqual(val, 2)
val = b.pop('c', 3)
self.assertEqual(val, 3)
def test_pop_with_1_invalid_key(self):
d = {
'a': 1,
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
val = b.pop('b')
val = b.pop('b', False)
self.assertFalse(val)
val = b.pop('b', None)
self.assertEqual(val, None)
def test_delitem_with_3_invalid_keys(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
}
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
del b['a.b.c.d']
self.assertEqual(b.get('a.b.c'), 1)
def test_get_with_keys_list_and_no_keypath_separator(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
},
}
b = KeypathDict(d, keypath_separator=None)
self.assertEqual(b.get(['a', 'b.c']), None)
self.assertEqual(b.get(['a', 'b', 'c']), 1)
self.assertEqual(b.get(['a', 'b', 'd']), 2)
self.assertEqual(b.get(['a', 'b', 'e']), None)
def test_delitem_with_keys_list_and_no_keypath_separator(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
}
}
b = KeypathDict(d, keypath_separator=None)
with self.assertRaises(KeyError):
del b['a', 'b', 'c', 'd']
del b['a', 'b', 'c']
self.assertEqual(b.get('a.b.c', 3), 3)
def test_update_with_dict_with_separator_in_keys(self):
d1 = {
'a': 1,
'b': 2,
'c': 3,
}
d2 = {
'a.x': 4,
'a.y': 5,
'a.z': 6,
}
b = KeypathDict(d1)
with self.assertRaises(ValueError):
b.update(d2)
def test_fromkeys(self):
k = [
'a',
'a.b',
'a.b.c',
'a.b.d',
'a.b.e',
'x',
'x.y',
'x.z',
]
b = KeypathDict.fromkeys(k)
r = {
'x': {
'y': None,
'z': None,
},
'a': {
'b': {
'c': None,
'd': None,
'e': None,
},
},
}
self.assertEqual(b, r)
def test_delitem_with_wrong_index(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
del b['a[5]']
def test_fromkeys_with_value(self):
k = [
'a',
'a.b',
'a.b.c',
'a.b.d',
'a.b.e',
'x',
'x.y',
'x.z',
]
b = KeypathDict.fromkeys(k, True)
r = {
'x': {
'y': True,
'z': True,
},
'a': {
'b': {
'c': True,
'd': True,
'e': True,
},
},
}
self.assertEqual(b, r)
def test_setitem_with_keys_list_and_no_keypath_separator(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
},
}
b = KeypathDict(d, keypath_separator=None)
b['a', 'b', 'c'] = 3
with self.assertRaises(KeyError):
val = b['a.b.c']
print(val)
self.assertEqual(b['a', 'b', 'c'], 3)
b['a', 'b', 'd'] = 4
with self.assertRaises(KeyError):
val = b['a.b.d']
print(val)
self.assertEqual(b['a', 'b', 'd'], 4)
b['a', 'b', 'e'] = 5
with self.assertRaises(KeyError):
val = b['a.b.e']
print(val)
self.assertEqual(b['a', 'b', 'e'], 5)
def test_contains_with_wrong_index(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
self.assertFalse('a[3]' in b)
self.assertFalse('a[]' in b)
def test_init_with_dict_with_separator_in_keys(self):
d = {
'a.b.c': 1,
'c.d.e': 2,
}
with self.assertRaises(ValueError):
KeypathDict(d)
def test_has_with_3_keys(self):
d = {
'a': {
'b': {
'c': 0,
'd': None,
'e': {},
'x': [1, 2, 3],
},
},
}
b = KeypathDict(d)
self.assertTrue('a.b.c' in b)
self.assertTrue('a.b.d' in b)
self.assertTrue('a.b.e' in b)
self.assertFalse('a.b.f' in b)
self.assertFalse('b.f' in b)
self.assertFalse('f' in b)
self.assertTrue('a.b.x[-1]' in b)
self.assertTrue('a.b.x[0]' in b)
self.assertTrue('a.b.x[1]' in b)
self.assertTrue('a.b.x[2]' in b)
self.assertFalse('a.b.x[3]' in b)
self.assertFalse(0 in b['a.b.x'])
self.assertTrue(1 in b['a.b.x'])
self.assertTrue(2 in b['a.b.x'])
self.assertTrue(3 in b['a.b.x'])
self.assertFalse(4 in b['a.b.x'])
def test_get_item_with_keys_list_and_no_keypath_separator(self):
d = {
'a': {
'b': {
'c': 1,
'd': 2,
},
},
}
b = KeypathDict(d, keypath_separator=None)
with self.assertRaises(KeyError):
val = b['a', 'b.c']
print(val)
self.assertEqual(b['a', 'b', 'c'], 1)
self.assertEqual(b[['a', 'b', 'c']], 1)
self.assertEqual(b[(
'a',
'b',
'c',
)], 1)
self.assertEqual(b['a', 'b', 'd'], 2)
self.assertEqual(b[['a', 'b', 'd']], 2)
self.assertEqual(b[(
'a',
'b',
'd',
)], 2)
with self.assertRaises(KeyError):
val = b['a', 'b', 'e']
print(val)
def test_init_without_keypath_separator(self):
d = {
'a': {
'b': 1,
'c': 2,
},
'd': {
'e': 3,
'f': 4,
},
}
b = KeypathDict(d, keypath_separator=None)
self.assertEqual(b.get('a.b'), None)
self.assertEqual(b.get('a.c'), None)
self.assertEqual(b.get('d.e'), None)
self.assertEqual(b.get('d.f'), None)
def test_getitem_with_wrong_index(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
self.assertEqual(b['a[5]'], 1)
def test_init_with_custom_separator(self):
d = {
'a.b': {
'c.d': 1,
'e.f': 2,
},
'g.h': {
'i.j': 3,
'k.l': 4,
},
}
b = KeypathDict(d, keypath_separator='/')
self.assertEqual(b.get('a.b/c.d'), 1)
self.assertEqual(b.get('a.b/e.f'), 2)
self.assertEqual(b.get('g.h/i.j'), 3)
self.assertEqual(b.get('g.h/k.l'), 4)
def test_getitem_with_1_invalid_key(self):
d = {
'a': 1,
}
b = KeypathDict(d)
with self.assertRaises(KeyError):
val = b['b']
print(val)
def test_delitem_with_2_valid_keys(self):
d = {
'a': {
'b': 1,
}
}
b = KeypathDict(d)
del b['a.b']
with self.assertRaises(KeyError):
del b['a.b']
self.assertEqual(b.get('a'), {})
del b['a']
with self.assertRaises(KeyError):
del b['a']
self.assertEqual(b.get('a'), None)
def test_keypath_separator_getter_setter(self):
d = KeypathDict({}, keypath_separator=None)
self.assertEqual(d.keypath_separator, None)
d['a.b.c'] = 1
with self.assertRaises(ValueError):
d.keypath_separator = '.'
d.keypath_separator = '/'
self.assertEqual(d.keypath_separator, '/')
d['x/y/z'] = 2
r = {
'a.b.c': 1,
'x': {
'y': {
'z': 2,
},
},
}
self.assertEqual(d, r)
def test_delitem_with_flat_list(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
del b['a[-1]']
del b['a[0]']
self.assertEqual(b, {'a': [2]})
def test_contains_with_flat_list(self):
d = {
'a': [1, 2, 3],
}
b = KeypathDict(d)
self.assertTrue('a[0]' in b)
self.assertTrue('a[1]' in b)
self.assertTrue('a[2]' in b)
self.assertTrue('a[-1]' in b)
def test_set_override_existing_item(self):
d = {}
b = KeypathDict(d)
b.set('a.b.c', 1)
r = {'a': {'b': {'c': 1}}}
b.set('a.b.c', 2)
r = {'a': {'b': {'c': 2}}}
self.assertEqual(b, r)
b.set('a.b.c.d', 3)
r = {'a': {'b': {'c': {'d': 3}}}}
self.assertEqual(b, r)
