class TestDotDict(unittest.TestCase): def setUp(self): self.dd = DotDict([('z', 1), (2, 'y'), ('x', 3)]) def test_get(self): assert_equal(self.dd[2], 'y') assert_equal(self.dd.x, 3) assert_raises(KeyError, self.dd.__getitem__, 'nonex') assert_raises(AttributeError, self.dd.__getattr__, 'nonex') def test_equality_with_normal_dict(self): assert_equal(self.dd, {'z': 1, 2: 'y', 'x': 3}) def test_set(self): self.dd.x = 42 self.dd.new = 43 self.dd[2] = 44 self.dd['n2'] = 45 assert_equal(self.dd, {'z': 1, 2: 44, 'x': 42, 'new': 43, 'n2': 45}) def test_del(self): del self.dd.x del self.dd[2] self.dd.pop('z') assert_equal(self.dd, {}) assert_raises(KeyError, self.dd.__delitem__, 'nonex') assert_raises(AttributeError, self.dd.__delattr__, 'nonex') def test_same_str_and_repr_format_as_with_normal_dict(self): D = {'foo': 'bar', '"\'': '"\'', '\n': '\r', 1: 2, (): {}, True: False} for d in {}, {'a': 1}, D: for formatter in str, repr: result = formatter(DotDict(d)) assert_equal(eval(result, {}), d) def test_is_ordered(self): assert_equal(list(self.dd), ['z', 2, 'x']) self.dd.z = 'new value' self.dd.a_new_item = 'last' self.dd.pop('x') assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last')]) self.dd.x = 'last' assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last'), ('x', 'last')]) def test_order_does_not_affect_equality(self): d = dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7) od1 = OrderedDict(sorted(d.items())) od2 = OrderedDict(reversed(list(od1.items()))) dd1 = DotDict(sorted(d.items())) dd2 = DotDict(reversed(list(dd1.items()))) for d1, d2 in [(dd1, dd2), (dd1, d), (dd2, d), (dd1, od1), (dd2, od2)]: assert_equal(d1, d2) assert_equal(d2, d1) if not IRONPYTHON: # https://github.com/IronLanguages/main/issues/1168 for d1, d2 in [(dd1, od2), (dd2, od1)]: assert_equal(d1, d2) assert_equal(d2, d1) assert_not_equal(od1, od2)
class TestDotDict(unittest.TestCase): def setUp(self): self.dd = DotDict([('z', 1), (2, 'y'), ('x', 3)]) def test_init(self): assert_true(DotDict() == DotDict({}) == DotDict([])) assert_true(DotDict(a=1) == DotDict({'a': 1}) == DotDict([('a', 1)])) assert_true(DotDict({'a': 1}, b=2) == DotDict({'a': 1, 'b': 2}) == DotDict([('a', 1), ('b', 2)])) assert_raises(TypeError, DotDict, None) def test_get(self): assert_equal(self.dd[2], 'y') assert_equal(self.dd.x, 3) assert_raises(KeyError, self.dd.__getitem__, 'nonex') assert_raises(AttributeError, self.dd.__getattr__, 'nonex') def test_equality(self): assert_true(self.dd == self.dd) assert_false(self.dd != self.dd) assert_true(self.dd == DotDict(self.dd)) assert_false(self.dd != DotDict(self.dd)) assert_false(self.dd == DotDict()) assert_true(self.dd != DotDict()) def test_equality_with_normal_dict(self): assert_equal(self.dd, {'z': 1, 2: 'y', 'x': 3}) def test_hash(self): assert_raises(TypeError, hash, self.dd) def test_set(self): self.dd.x = 42 self.dd.new = 43 self.dd[2] = 44 self.dd['n2'] = 45 assert_equal(self.dd, {'z': 1, 2: 44, 'x': 42, 'new': 43, 'n2': 45}) def test_del(self): del self.dd.x del self.dd[2] self.dd.pop('z') assert_equal(self.dd, {}) assert_raises(KeyError, self.dd.__delitem__, 'nonex') assert_raises(AttributeError, self.dd.__delattr__, 'nonex') def test_same_str_and_repr_format_as_with_normal_dict(self): D = {'foo': 'bar', '"\'': '"\'', '\n': '\r', 1: 2, (): {}, True: False} for d in {}, {'a': 1}, D: for formatter in str, repr: result = formatter(DotDict(d)) assert_equal(eval(result, {}), d) def test_is_ordered(self): assert_equal(list(self.dd), ['z', 2, 'x']) self.dd.z = 'new value' self.dd.a_new_item = 'last' self.dd.pop('x') assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last')]) self.dd.x = 'last' assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last'), ('x', 'last')]) def test_order_does_not_affect_equality(self): d = dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7) od1 = OrderedDict(sorted(d.items())) od2 = OrderedDict(reversed(list(od1.items()))) dd1 = DotDict(sorted(d.items())) dd2 = DotDict(reversed(list(dd1.items()))) for d1, d2 in [(dd1, dd2), (dd1, d), (dd2, d), (dd1, od1), (dd2, od2)]: assert_equal(d1, d2) assert_equal(d2, d1) if not IRONPYTHON: # https://github.com/IronLanguages/main/issues/1168 for d1, d2 in [(dd1, od2), (dd2, od1)]: assert_equal(d1, d2) assert_equal(d2, d1) assert_not_equal(od1, od2)
class TestDotDict(unittest.TestCase): def setUp(self): self.dd = DotDict([('z', 1), (2, 'y'), ('x', 3)]) def test_get(self): assert_equal(self.dd[2], 'y') assert_equal(self.dd.x, 3) assert_raises(KeyError, self.dd.__getitem__, 'nonex') assert_raises(AttributeError, self.dd.__getattr__, 'nonex') def test_equality(self): assert_true(self.dd == self.dd) assert_false(self.dd != self.dd) assert_true(self.dd == DotDict(self.dd)) assert_false(self.dd != DotDict(self.dd)) assert_false(self.dd == DotDict()) assert_true(self.dd != DotDict()) def test_equality_with_normal_dict(self): assert_equal(self.dd, {'z': 1, 2: 'y', 'x': 3}) def test_hash(self): assert_raises(TypeError, hash, self.dd) def test_set(self): self.dd.x = 42 self.dd.new = 43 self.dd[2] = 44 self.dd['n2'] = 45 assert_equal(self.dd, {'z': 1, 2: 44, 'x': 42, 'new': 43, 'n2': 45}) def test_del(self): del self.dd.x del self.dd[2] self.dd.pop('z') assert_equal(self.dd, {}) assert_raises(KeyError, self.dd.__delitem__, 'nonex') assert_raises(AttributeError, self.dd.__delattr__, 'nonex') def test_same_str_and_repr_format_as_with_normal_dict(self): D = {'foo': 'bar', '"\'': '"\'', '\n': '\r', 1: 2, (): {}, True: False} for d in {}, {'a': 1}, D: for formatter in str, repr: result = formatter(DotDict(d)) assert_equal(eval(result, {}), d) def test_is_ordered(self): assert_equal(list(self.dd), ['z', 2, 'x']) self.dd.z = 'new value' self.dd.a_new_item = 'last' self.dd.pop('x') assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last')]) self.dd.x = 'last' assert_equal(list(self.dd.items()), [('z', 'new value'), (2, 'y'), ('a_new_item', 'last'), ('x', 'last')]) def test_order_does_not_affect_equality(self): d = dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7) od1 = OrderedDict(sorted(d.items())) od2 = OrderedDict(reversed(list(od1.items()))) dd1 = DotDict(sorted(d.items())) dd2 = DotDict(reversed(list(dd1.items()))) for d1, d2 in [(dd1, dd2), (dd1, d), (dd2, d), (dd1, od1), (dd2, od2)]: assert_equal(d1, d2) assert_equal(d2, d1) if not IRONPYTHON: # https://github.com/IronLanguages/main/issues/1168 for d1, d2 in [(dd1, od2), (dd2, od1)]: assert_equal(d1, d2) assert_equal(d2, d1) assert_not_equal(od1, od2) def test_nested_dicts(self): leaf = {'key': 'value'} d = DotDict({ 'nested': leaf, 'deeper': { 'nesting': leaf } }, nested2=leaf) assert_equal(d.nested.key, 'value') assert_equal(d.deeper.nesting.key, 'value') assert_equal(d.nested2.key, 'value') def test_nested_dicts_inside_list_likes(self): leaf = {'key': 'value'} d = DotDict(list=[leaf, leaf, [leaf]], tuple=(leaf, {'deeper': leaf})) assert_equal(d.list[0].key, 'value') assert_equal(d.list[1].key, 'value') assert_equal(d.list[2][0].key, 'value') assert_equal(d.tuple[0].key, 'value') assert_equal(d.tuple[1].deeper.key, 'value') assert_true(isinstance(d.tuple, list))