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()