def test_strange_addition(self): m = DotMap() m += "I'm a string now" self.assertIsInstance(m, str) self.assertNotIsInstance(m, DotMap) self.assertEqual(m, "I'm a string now") m2 = DotMap() + "I'll replace that DotMap" self.assertEqual(m2, "I'll replace that DotMap")
def test_string_addition(self): m = DotMap() m.quote += 'lions' m.quote += ' and tigers' m.quote += ' and bears' m.quote += ', oh my' self.assertEqual(m.quote, 'lions and tigers and bears, oh my')
def test(self): m = DotMap() self.assertTrue(m.empty()) m.a = 1 self.assertFalse(m.empty()) self.assertTrue(m.b.empty()) self.assertIsInstance(m.b, DotMap)
def test_base(self): m = DotMap() for i in range(7): m.counter += 1 self.assertNotIsInstance(m.counter, DotMap) self.assertIsInstance(m.counter, int) self.assertEqual(m.counter, 7)
def test(self): a = {'1': 'a', '2': 'b'} b = DotMap(a, _dynamic=False) def capture(**kwargs): return kwargs self.assertEqual(a, capture(**b.toDict()))
def test_type_error_raised(self): m = DotMap() def badAddition(): m.a += 1 m.a += ' and tigers' self.assertRaises(TypeError, badAddition)
def test_protected_hierarchy(self): m = DotMap() m.protected_parent.key = 'value' def protectedFromAddition(): m.protected_parent += 1 self.assertRaises(TypeError, protectedFromAddition)
def test_dict_init(self): m = DotMap(self.d) self.assertIsInstance(m, DotMap) self.assertEqual(m.a, 1) self.assertEqual(m.b, 2) self.assertIsInstance(m.subD, DotMap) self.assertEqual(m.subD.c, 3) self.assertEqual(m.subD.d, 4)
def test(self): m = DotMap() m.a = 5 m_id = id(m) m.recursive = m self.assertEqual(id(m.recursive.recursive.recursive), m_id) self.assertEqual(str(m), '''DotMap(a=5, recursive=DotMap(...))''') d = m.toDict() d_id = id(d) d['a'] = 5 d['recursive'] = d d['recursive']['recursive']['recursive'] self.assertEqual(id(d['recursive']['recursive']['recursive']), d_id) self.assertEqual(str(d), '''{'a': 5, 'recursive': {...}}''') m2 = DotMap(d) m2_id = id(m2) self.assertEqual(id(m2.recursive.recursive.recursive), m2_id) self.assertEqual(str(m2), '''DotMap(a=5, recursive=DotMap(...))''')
def test_copy(self): m = DotMap(self.d) dm_copy = m.copy() self.assertIsInstance(dm_copy, DotMap) self.assertEqual(dm_copy.a, 1) self.assertEqual(dm_copy.b, 2) self.assertIsInstance(dm_copy.subD, DotMap) self.assertEqual(dm_copy.subD.c, 3) self.assertEqual(dm_copy.subD.d, 4)
def test(self): m = DotMap() m.still.works m.sub.still.works nonDynamic = DotMap(_dynamic=False) def assignNonDynamic(): nonDynamic.no self.assertRaises(KeyError, assignNonDynamic) nonDynamicWithInit = DotMap(m, _dynamic=False) nonDynamicWithInit.still.works nonDynamicWithInit.sub.still.works def assignNonDynamicWithInit(): nonDynamicWithInit.no.creation self.assertRaises(KeyError, assignNonDynamicWithInit)
def test_various(self): m = DotMap() m.a.label = 'test' m.a.counter += 2 self.assertIsInstance(m.a, DotMap) self.assertEqual(m.a.label, 'test') self.assertNotIsInstance(m.a.counter, DotMap) self.assertIsInstance(m.a.counter, int) self.assertEqual(m.a.counter, 2) m.a.counter += 1 self.assertEqual(m.a.counter, 3)
def test(self): import pickle pm = DotMap(self.d) s = pickle.dumps(pm) m = pickle.loads(s) self.assertIsInstance(m, DotMap) self.assertEqual(m.a, 1) self.assertEqual(m.b, 2) self.assertIsInstance(m.subD, DotMap) self.assertEqual(m.subD.c, 3) self.assertEqual(m.subD.d, 4)
def test_basic_use(self): m = DotMap() self.assertIsInstance(m, DotMap) m.name = 'Joe' self.assertEqual(m.name, 'Joe') self.assertEqual('Hello ' + m.name, 'Hello Joe') self.assertIsInstance(m, dict) self.assertTrue(issubclass(m.__class__, dict)) self.assertEqual(m['name'], 'Joe') m.name += ' Smith' m['name'] += ' Jr' self.assertEqual(m.name, 'Joe Smith Jr')
def test_order_preserved(self): import copy original = DotMap() original.a = 1 original.b = 2 original.c = 3 deepCopy = copy.deepcopy(original) orderedPairs = [] for k, v in original.iteritems(): orderedPairs.append((k, v)) for i, (k, v) in enumerate(deepCopy.iteritems()): self.assertEqual(k, orderedPairs[i][0]) self.assertEqual(v, orderedPairs[i][1])
def test_dict_functionality(self): m = DotMap(self.d) self.assertEqual(m.get('a'), 1) self.assertEqual(m.get('f', 33), 33) self.assertIsNone(m.get('f')) self.assertTrue(m.has_key('a')) self.assertFalse(m.has_key('f')) m.update([('rat', 5), ('bum', 4)], dog=7, cat=9) self.assertEqual(m.rat, 5) self.assertEqual(m.bum, 4) self.assertEqual(m.dog, 7) self.assertEqual(m.cat, 9) m.update({'lol': 1, 'ba': 2}) self.assertEqual(m.lol, 1) self.assertEqual(m.ba, 2) ordered_keys = [ 'a', 'b', 'subD', 'rat', 'bum', 'dog', 'cat', 'lol', 'ba', ] for i, k in enumerate(m): self.assertEqual(ordered_keys[i], k) self.assertTrue('a' in m) self.assertFalse('c' in m) ordered_values = [1, 2, DotMap(c=3, d=4), 5, 4, 7, 9, 1, 2] for i, v in enumerate(m.values()): self.assertEqual(ordered_values[i], v) self.assertTrue('c' in m.subD) self.assertTrue(len(m.subD), 2) del m.subD.c self.assertFalse('c' in m.subD) self.assertTrue(len(m.subD), 1)
def test_proposal(self): my_counters = DotMap() pages = [ 'once upon a time', 'there was like this super awesome prince', 'and there was this super rad princess', 'and they had a mutually respectful, egalitarian relationship', 'the end' ] for stuff in pages: my_counters.page += 1 self.assertIsInstance(my_counters, DotMap) self.assertNotIsInstance(my_counters.page, DotMap) self.assertIsInstance(my_counters.page, int) self.assertEqual(my_counters.page, 5)
def test(self): import copy original = DotMap() original.a = 1 original.b = 3 shallowCopy = original deepCopy = copy.deepcopy(original) self.assertEqual(original, shallowCopy) self.assertEqual(id(original), id(shallowCopy)) self.assertEqual(original, deepCopy) self.assertNotEqual(id(original), id(deepCopy)) original.a = 2 self.assertEqual(original, shallowCopy) self.assertNotEqual(original, deepCopy)
def test_dict_conversion(self): d = {'a': 1, 'b': 2, 'c': {'d': 3, 'e': 4}} m = DotMap(d) self.assertEqual(m.a, 1) self.assertEqual(m.b, 2) d2 = m.toDict() self.assertIsInstance(d2, dict) self.assertNotIsInstance(d2, DotMap) self.assertEqual(len(d2), 3) self.assertEqual(d2['a'], 1) self.assertEqual(d2['b'], 2) self.assertNotIsInstance(d2['c'], DotMap) self.assertEqual(len(d2['c']), 2) self.assertEqual(d2['c']['d'], 3) self.assertEqual(d2['c']['e'], 4)
def test_ordered_iteration(self): m = DotMap() m.people.john.age = 32 m.people.john.job = 'programmer' m.people.mary.age = 24 m.people.mary.job = 'designer' m.people.dave.age = 55 m.people.dave.job = 'manager' expected = [ ('john', 32, 'programmer'), ('mary', 24, 'designer'), ('dave', 55, 'manager'), ] for i, (k, v) in enumerate(m.people.items()): self.assertEqual(expected[i][0], k) self.assertEqual(expected[i][1], v.age) self.assertEqual(expected[i][2], v.job)
def test_list_comprehension(self): parentDict = { 'name': 'Father1', 'children': [ { 'name': 'Child1' }, { 'name': 'Child2' }, { 'name': 'Child3' }, ] } parent = DotMap(parentDict) ordered_names = ['Child1', 'Child2', 'Child3'] comp = [x.name for x in parent.children] self.assertEqual(ordered_names, comp)
def test(self): from collections import OrderedDict o = OrderedDict([('a', 1), ('b', 2), ('c', [OrderedDict([('d', 3)])])]) m = DotMap(o) self.assertIsInstance(m, DotMap) self.assertIsInstance(m.c[0], DotMap)
def test(self): m = DotMap({'a': 1, 'b': (11, 22, DotMap({'c': 3}))}) d = m.toDict() self.assertEqual(d, {'a': 1, 'b': (11, 22, {'c': 3})})
def test_key_init(self): m = DotMap(a=1, b=2) self.assertEqual(m.a, 1) self.assertEqual(m.b, 2)
def test_automatic_hierarchy(self): m = DotMap() m.people.steve.age = 31 self.assertEqual(m.people.steve.age, 31)