def test_flatten():
"""Flatenning the dictionary."""
flex = FlexDict(DATA)
assert sorted(flex.flatten()) == [(['a', 'b', 'c'], 1), (['a', 'b',
'd'], 2),
(['e', 'f'], 3), (['e', 'g'], 4),
(['h'], 5)]
def test_equals():
"""Equality comparisons."""
flex = FlexDict()
assert (flex == flex) is True
assert (flex is flex) is True
assert (flex == FlexDict()) is True
assert (flex is FlexDict()) is False
def test_pop():
"""Popping items from the dictionary."""
flex = FlexDict(DATA)
items = list(flex.items())[::-1]
for key, val in items:
assert flex.pop() == {key: val}
assert flex.pop() is None
def test_lock_inplace_false():
"""Creating a locked and unlocked copies."""
flex = FlexDict(DATA)
flex_locked = flex.lock(inplace=False)
flex_unlocked = flex_locked.unlock(inplace=False)
assert flex.locked is False
assert flex_locked.locked is True
assert flex_unlocked.locked is False
def test_lock_error():
"""KeyError after locking."""
flex = FlexDict(DATA)
flex.lock()
with raises(KeyError):
flex['z', 'k'] # pylint: disable=W0104
with raises(KeyError):
flex['z', 'k'] = 1
assert flex == DATA
def test_hash_equals():
"""Hash equality comparisons. hash(FlexDict()) == hash(FlexDict())"""
f = FlexDict()
g = FlexDict()
assert (hash(f) == hash(g)) is True
assert (hash(f) == hash(f)) is True
f["foo", "bar"] = 1
g["bar", "foo"] = 1
assert (hash(f) == hash(g)) is False
def test_values_unique():
"""Getting unique values."""
flex = FlexDict(DATA)
assert all([
item in [{
'b': {
'c': 1,
'd': 2
}
}, {
'f': 3,
'g': 4
}, 5] for item in flex.values(unique=True)
]) is True
def test_unlock(keys):
"""Recursive (un)locking mechanism."""
flex = FlexDict(DATA)
flex.lock()
flex.unlock()
assert flex.locked is False
assert flex[keys].locked is False
def test_init_value_error():
"""Invalid initialization."""
data = {1, 2}
with raises(ValueError):
FlexDict(data)
def test_inside(s_set, flag):
"""Superset detection."""
assert FlexDict(s_set).inside(DATA) is flag
def test_keys_unique():
"""Getting unique keys."""
flex = FlexDict(DATA)
assert sorted(flex.keys(unique=True)) == sorted(set(DATA.keys()))
def test_init_lock(keys):
"""Recursive locking on init."""
flex = FlexDict(DATA)
assert flex.locked is False
assert flex[keys].locked is False
def test_contains(s_set, flag):
"""Subset detection."""
flex = FlexDict(DATA)
assert flex.contains(s_set) is flag
def test_get_function(get_keys, get_val):
"""Getting value."""
flex = FlexDict(DATA)
assert flex.get(get_keys) == get_val
def test_set_func(set_keys, set_val):
"""Setting values."""
flex = FlexDict()
flex.set(set_keys, set_val)
assert flex[set_keys] == set_val
def test_values():
"""Getting values."""
flex = FlexDict(DATA)
assert list(flex.values()) == list(DATA.values())
def test_get(get_keys, get_val):
"""Getting values."""
flex = FlexDict(DATA)
assert flex[get_keys] == get_val
def test_values_nested():
"""Getting nested values."""
flex = FlexDict(DATA)
assert sorted(flex.values(nested=True)) == [1, 2, 3, 4, 5]
def test_lock(keys):
"""Recursive locking mechanism."""
flex = FlexDict(DATA)
flex.lock()
assert flex.locked is True
assert flex[keys].locked is True
def test_length_nested_unique():
"""Recursively getting the total number of unique keys."""
flex = FlexDict(DATA)
assert flex.length(nested=True, unique=True) == 8
def test_length_unique():
"""Getting the number of keys."""
flex = FlexDict(DATA)
assert flex.length(unique=True) == 3
def test_length():
"""Getting the dictionary length."""
flex = FlexDict(DATA)
assert flex.length() == 3
def test_keys_nested():
"""Getting nested keys."""
flex = FlexDict(DATA)
assert sorted(
flex.keys(nested=True)) == ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
def test_values_nested_unique():
"""Getting nested unique values."""
flex = FlexDict(DATA)
assert flex.values(nested=True, unique=True) == {1, 2, 3, 4, 5}
def test_size():
"""Recursively count the total number of keys and values."""
flex = FlexDict(DATA)
assert flex.size() == 13
def test_keys_nested_unique():
"""Getting nested unique keys."""
flex = FlexDict(DATA)
assert flex.keys(nested=True,
unique=True) == {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}
def test_init():
"""Initialization with dictionary."""
assert FlexDict() == dict()
assert FlexDict(DATA) == DATA
def test_size_unique():
"""Recursively count the total number of unique keys and values."""
flex = FlexDict(DATA)
assert flex.size(unique=True) == 13
def test_unlock_set():
"""Set values after unlocking."""
flex = FlexDict(DATA)
flex.lock()
flex.unlock()
flex['z', 'k'] = 1
def test_keys():
"""Getting keys."""
flex = FlexDict(DATA)
assert flex.keys() == DATA.keys()
