def test_contains_plain_present():
assert 'foo' in objict(foo='bar')
assert 'bar' not in objict(foo='bar')
assert None in objict.fromdict({None: ''})
ud = objict.fromdict({1: 2, 3: 4})
assert 1 in ud
assert 2 not in ud
assert 3 in ud
def test_fromdict_objicts():
d = {
'one.two': 'one.two',
'one': {
'two': 'one->two'
}
}
orig = objict.fromdict(d)
ud = objict.fromdict(orig)
assert items(ud) == items(d)
def test_popitem_dotted():
orig = objict.fromdict({
'a': {'b': 'a->b'},
'a.b': 'a.b'
})
# popitem removes a random (key, value) pair, so do that enough
# times to verify that when doing popitem on above, we only
# ever see the 'a.b' top-level mapping removed or the
# 'a' top-level mapping removed, never the child ('b', 'a->b') mapping
for i in range(20):
ud = objict.fromdict(orig)
assert ud.popitem() in (
('a', objict(b='a->b')),
('a.b', 'a.b')
)
def test_pop_nested():
d = {
'a': 'aa',
'b': 'bb',
'a': {'b': {'c': 'a->b->c'}},
}
ud = objict.fromdict(d)
assert ud['a.b.c'] == 'a->b->c'
val = ud.pop('a.b.c')
assert val == 'a->b->c'
def test_hasattr_nested():
ud = objict.fromdict({
'a': {
'b': 'a->b'
}
})
assert hasattr(ud, 'a.b')
assert ud.get("a.b") != None
assert hasattr(ud, 'a')
assert hasattr(ud['a'], 'b')
def test_update():
orig = {
'a': {'b': 'a->b'},
'a.b': 'a.b',
'c': 'c'
}
ud = objict.fromdict(orig)
ud.update({'a': 'a'})
assert ud['a'] == 'a'
assert ud['c'] == orig['c']
with pytest.raises(TypeError):
ud['a.b'] # ud['a'] doesn't support __getitem__
assert getattr(ud, 'a.b') == 'a.b'
ud = objict.fromdict(orig)
ud.update(objict({'a.b': 'b.a'}))
assert ud['a.b'] == 'a->b'
assert ud['a'] == objict(b='a->b')
assert ud['c'] == 'c'
def test_pop_dotted():
d = {
'a': objict(b='a->b'),
'b': 'bb',
'a.b': 'a.b'
}
ud = objict.fromdict(d)
val = ud.pop('a.b')
assert val == 'a->b'
assert ud['a'] == objict()
def test_delitem_second_level_first_exists_fail():
ud = objict.fromdict({
'one': {
'two': 'one->two'
}
})
try:
del ud['one.three']
pytest.fails()
except KeyError as e:
assert e.args == ('three',)
def test_dir_omits_nested_keys():
ud = objict.fromdict({
'a': {
'b': 'a->b'
},
'a.c': 'a.c'
})
attrs = dir(ud)
assert 'a' in attrs
assert 'a.b' not in attrs
assert 'a.c' in attrs
def test_hasattr_nested_dotted():
ud = objict.fromdict({
'a': {
'b': 'a->b',
'c': 'a->c'
},
'a.b': 'a.b'
})
assert hasattr(ud, 'a')
assert hasattr(ud, 'a.b')
assert hasattr(ud, 'a.c')
def test_getattr_dotted_key():
ud = objict.fromdict({
'a.b': 'abab',
'a': {'b': 'abab'}
})
uda = ud['a']
assert uda == objict(b='abab')
assert getattr(ud, 'a.b') == 'abab'
assert getattr(ud, 'a') == uda
assert ud.a == uda
assert ud.a.b == 'abab'
def test_pickle_dumpsloads_nested_dotted():
orig = objict.fromdict({
'one': {
'two': 'one->two'
},
'one.two': 'one.two'
})
unpickled = pickle.loads(pickle.dumps(orig))
# assert unpickled == orig
assert items(unpickled) == items(orig)
assert isinstance(unpickled, objict)
assert isinstance(unpickled['one'], objict)
def test_fromkeys_value():
ud = objict.fromkeys([], 1)
assert ud == objict()
assert ud == dict.fromkeys([], 1)
ud = objict.fromkeys(range(1), 1)
assert ud == objict.fromdict({0: 1})
assert ud == dict.fromkeys(range(1), 1)
ud = objict.fromkeys(range(10), 0)
assert ud == objict((i, 0) for i in range(10))
assert ud == dict.fromkeys(range(10), 0)
def test_getitem_multilevel_returns_value():
ud = objict.fromdict({
'one': {
'two': 'one->two'
},
'a': {
'b': {'c': 'a->b->c'}
}
})
assert ud['one.two'] == 'one->two'
assert ud['a.b'] == {'c': 'a->b->c'}
assert ud['a.b.c'] == 'a->b->c'
def test_values_dotted_keys():
ud = objict.fromdict({
'a': dict(b='ab'),
'b': 'bb',
'a.b': 'a.ba.b'
})
values = ud.values()
assert 'bb' in values
assert 'a.ba.b' in values
assert objict(b='ab') in values
del ud['a']
assert sorted(ud.values()) == ['a.ba.b', 'bb']
def test_setdefault_value_dotted_key_present():
ud = objict.fromdict({
'a': {
'b': {
'c1': 'abc'
}
}
})
res = ud.setdefault('a.b', objict())
res['c2'] = 'cba'
assert set(ud.keys()) == set(['a'])
assert ud.get('a.b.c2') == 'cba'
assert ud.get('a.b.c1') == 'abc'
def test_todict_dotted_keys():
orig = {
'one.two': 'one.two',
'one': {'two': 'one->two'}
}
ud = objict.fromdict(orig)
assert isinstance(ud['one'], objict)
d = ud.todict()
assert items(d) == [
('one', {'two': 'one->two'}),
('one.two', 'one.two')
]
assert type(items(d)[0][1]) is dict
def test_delattr_dotted_key_present_dotted_toplevel():
d = {
'one.two': 'one.two',
'one': {
'two': 'one->two'
}
}
ud = objict.fromdict(d)
del ud['one.two']
assert items(ud) == [
('one', objict()),
('one.two', 'one.two')
]
def test_fromdict_dotted_key():
d = {
'a.b': 'a.b',
'a': {
'b': 'a->b'
}
}
ud = objict.fromdict(d)
elems = items(ud)
assert elems == [
('a', objict(b='a->b')),
('a.b', 'a.b')
]
assert type(elems[0][1]) is objict
def test_fromdict_nested_dicts():
d = {
'a': {
'b': {
'c': 'a->b->c'
}
}
}
ud = objict.fromdict(d)
elems = items(ud)
assert elems == [
('a', objict({'b': objict({'c': 'a->b->c'})}))
]
assert type(elems[0][1]) is objict
def test_delitem_second_level_success():
ud = objict.fromdict({
'one': {
'two': 2,
'blah': {
'three': 3
}
}
})
del ud['one.blah']
assert items(ud) == [
('one', objict(two=2))
]
del ud['one.two']
assert items(ud) == [('one', objict())]
def test_getitem_multilevel_fail():
ud = objict.fromdict({
'one': {
'two': 'one->two'
},
'a': {
'b': {'c': 'a->b->c'}
}
})
try:
ud['one.three']
pytest.fail()
except KeyError as e: # success
# verify args contains first failing token
assert e.args == ('three',)
try:
ud['a.b.x']
pytest.fail()
except KeyError as e:
assert e.args == ('x',)
with pytest.raises(TypeError):
# ud['a.b.c'] doesn't support indexing
ud['a.b.c.d']
def objict_(dict_):
return objict.fromdict(dict_)
def test_keys():
d = dict(foo=dict(bar='barbar'))
ud = objict.fromdict(d)
assert ud.keys()
assert ud.keys() == d.keys()
def test_fromdict_classmethod():
ud = objict.fromdict({})
assert isinstance(ud, objict)
assert ud == objict()
