bison/tests/test_utils.py

498 lines
14 KiB
Python
Raw Normal View History

2018-03-07 22:54:13 -07:00
"""Unit tests for bison.utils"""
import pytest
from bison import utils
2018-03-07 22:54:13 -07:00
@pytest.mark.parametrize(
'key,value,expected', [
('a', 'b', ('a', 'b')),
('a.b', 'c', ('a', {'b': 'c'})),
('a.b.c', None, ('a', {'b': {'c': None}})),
('a.b.c', 1, ('a', {'b': {'c': 1}})),
('a.b.c', True, ('a', {'b': {'c': True}}))
]
)
def test_build_dot_value(key, value, expected):
"""Test building new dictionaries based off of a dot notation key"""
res = utils.build_dot_value(key, value)
assert res == expected
class TestDotDict:
"""Tests for the DotDict class."""
@pytest.mark.parametrize(
'param,expected', [
(None, {}),
({}, {}),
({'a': 'b'}, {'a': 'b'}),
({'a': 1, 'b': {'c': None}}, {'a': 1, 'b': {'c': None}})
]
)
def test_init(self, param, expected):
"""Initialize a new DotDict."""
dd = utils.DotDict(param)
assert dd == expected
@pytest.mark.parametrize(
'key,expected', [
('z', None),
('x.y.z', None),
('c.d.g', None),
('', None),
('a', 1),
('b', None),
('c', {'f': 'bar', 'd': {'e': 'foo'}}),
('c.d', {'e': 'foo'}),
('c.d.e', 'foo'),
('c.f', 'bar'),
('g', False)
]
)
def test_get(self, key, expected):
"""Get values from the DotDict."""
dd = utils.DotDict({
'a': 1,
'b': None,
'c': {
'd': {
'e': 'foo'
},
'f': 'bar'
},
'g': False
})
# test getting values via the .get() method
value = dd.get(key)
assert value == expected
# test getting values via dictionary access methods
value = dd[key]
assert value == expected
@pytest.mark.parametrize(
'key', [
'a',
'c',
'c.d',
'c.d.e',
'c.f'
]
)
def test_delete_1(self, key):
"""Delete values from the DotDict that exist."""
dd = utils.DotDict({
'a': 1,
'c': {
'd': {
'e': 'foo'
},
'f': 'bar'
}
})
value = dd.get(key)
assert value is not None
# delete via the .delete() method
dd.delete(key)
value = dd.get(key)
assert value is None
@pytest.mark.parametrize(
'key', [
'a',
'c'
]
)
def test_delete_2(self, key):
"""Delete values from the DotDict using del"""
dd = utils.DotDict({
'a': 1,
'c': {
'd': {
'e': 'foo'
},
'f': 'bar'
}
})
value = dd[key]
assert value is not None
# delete via the del keyword. since we are testing
# first order keys, they should all resolve, so they
# can be deleted successfully.
del dd[key]
value = dd[key]
assert value is None
@pytest.mark.parametrize(
'key', [
'x',
'x.y.z',
'',
'c.e',
'c.d.e',
'c.d.e.f'
]
)
def test_delete_3(self, key):
"""Delete values that do not exist from the DotDict."""
dd = utils.DotDict({
'a': 1,
'b': None,
'c': {
'd': 'foo',
'f': 'bar'
}
})
# delete via the .delete() method
with pytest.raises(KeyError):
dd.delete(key)
@pytest.mark.parametrize(
'key', [
'c.d',
'c.d.e',
'c.f'
]
)
def test_delete_4(self, key):
"""Delete values from the DotDict using del"""
dd = utils.DotDict({
'a': 1,
'c': {
'd': {
'e': 'foo'
},
'f': 'bar'
}
})
# delete via the del keyword. dot notation keys
# should fail resolution and raise a KeyError
with pytest.raises(KeyError):
del dd[key]
@pytest.mark.parametrize(
'key,value', [
('a', 'foo'),
('b', 'bar'),
('b.c', False),
('x', 1),
('x.y', [1, 2, 3]),
('x.y.z', 'baz'),
('x.y.z.q', {'a': 'foo', 'b': [1, 2, 3]})
]
)
def test_set(self, key, value):
"""Set an item in the DotDict"""
dd = utils.DotDict({
'a': 1,
'b': {'c': True}
})
dd[key] = value
assert dd.get(key) == value
2018-03-08 14:55:45 -07:00
def test_set_multiple_nested(self):
"""Set multiple nested items"""
dd = utils.DotDict()
assert dd == {}
dd['foo.bar.a'] = 'test'
assert dd == {
'foo': {
'bar': {
'a': 'test'
}
}
}
dd['foo.bar.b'] = 'test'
assert dd == {
'foo': {
'bar': {
'a': 'test',
'b': 'test'
}
}
}
def test_set_multiple_neste2(self):
"""Set multiple nested items"""
dd = utils.DotDict()
assert dd == {}
dd['foo'] = 'test'
assert dd == {
'foo': 'test'
}
dd['bar.baz'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test'
}
}
dd['bar.ball'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test'
}
}
dd['bar.bits.a'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test',
'bits': {
'a': 'test'
}
}
}
dd['bar.bits.b'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test',
'bits': {
'a': 'test',
'b': 'test'
}
}
}
dd['bar.new.a'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test',
'bits': {
'a': 'test',
'b': 'test'
},
'new': {
'a': 'test'
}
}
}
dd['bar.new.b.c.d'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test',
'bits': {
'a': 'test',
'b': 'test'
},
'new': {
'a': 'test',
'b': {
'c': {
'd': 'test'
}
}
}
}
}
dd['bar.new.b'] = 'test'
assert dd == {
'foo': 'test',
'bar': {
'baz': 'test',
'ball': 'test',
'bits': {
'a': 'test',
'b': 'test'
},
'new': {
'a': 'test',
'b': 'test'
}
}
}
dd['bar'] = 'test'
assert dd == {
'foo': 'test',
'bar': 'test'
}
dd['foo.bar.a'] = 'test'
assert dd == {
'foo': {
'bar': {
'a': 'test'
}
},
'bar': 'test'
}
dd['foo'] = ['a', 'b', 'c']
assert dd == {
'foo': ['a', 'b', 'c'],
'bar': 'test'
}
dd['foo.bar.b'] = ['a', 'b', 'c']
assert dd == {
'foo': {
'bar': {
'b': ['a', 'b', 'c']
}
},
'bar': 'test'
}
2018-03-07 22:54:13 -07:00
@pytest.mark.parametrize(
'key,expected', [
('a', True),
('a.b', False),
('a.b.c', False),
('b', True),
('b.c', True),
('b.c', True),
('b.a', False),
('b.c.d', True),
('b.c.d.e', False),
('b.c.d.e.f', False),
('g', False),
('g.e', False),
]
)
def test_inclusion(self, key, expected):
"""Check if a key exists in a DotDict"""
dd = utils.DotDict({
'a': 1,
'b': {
'c': {
'd': 'foo'
}
}
})
assert (key in dd) is expected
@pytest.mark.parametrize(
'source,expected', [
({}, {'foo': 'bar', 'bar': {'baz': {'key': 'value'}}}),
({'foo': 'test'}, {'foo': 'test', 'bar': {'baz': {'key': 'value'}}}),
({'abc': '123'}, {'foo': 'bar', 'abc': '123', 'bar': {'baz': {'key': 'value'}}}),
({'bar': 'test'}, {'foo': 'bar', 'bar': 'test'}),
({'bar': {'test': 'value'}}, {'foo': 'bar', 'bar': {'test': 'value'}}),
({'test': 123}, {'foo': 'bar', 'test': 123, 'bar': {'baz': {'key': 'value'}}}),
({'foo': 123}, {'foo': 123, 'bar': {'baz': {'key': 'value'}}}),
({'bar': 123}, {'foo': 'bar', 'bar': 123}),
({'test': [1, 2, 3]}, {'foo': 'bar', 'test': [1, 2, 3], 'bar': {'baz': {'key': 'value'}}}),
({'foo': [1, 2, 3]}, {'foo': [1, 2, 3], 'bar': {'baz': {'key': 'value'}}}),
({'bar': [1, 2, 3]}, {'foo': 'bar', 'bar': [1, 2, 3]}),
({'test': {'a': 1}}, {'foo': 'bar', 'test': {'a': 1}, 'bar': {'baz': {'key': 'value'}}}),
({'foo': {'a': 1}}, {'foo': {'a': 1}, 'bar': {'baz': {'key': 'value'}}}),
({'bar': {'a': 1}}, {'foo': 'bar', 'bar': {'a': 1}}),
({'test': False}, {'foo': 'bar', 'test': False, 'bar': {'baz': {'key': 'value'}}}),
({'foo': False}, {'foo': False, 'bar': {'baz': {'key': 'value'}}}),
({'bar': False}, {'foo': 'bar', 'bar': False}),
({'test': None}, {'foo': 'bar', 'test': None, 'bar': {'baz': {'key': 'value'}}}),
({'foo': None}, {'foo': None, 'bar': {'baz': {'key': 'value'}}}),
({'bar': None}, {'foo': 'bar', 'bar': None}),
]
)
def test_update(self, source, expected):
"""Update the DotDict"""
dd = utils.DotDict({
'foo': 'bar',
'bar': {
'baz': {
'key': 'value'
}
}
})
dd.update(source)
assert dd == expected
@pytest.mark.parametrize(
'source,expected', [
({}, {'foo': 'bar', 'bar': {'baz': {'key': 'value'}}}),
({'foo': 'test'}, {'foo': 'test', 'bar': {'baz': {'key': 'value'}}}),
({'abc': '123'}, {'foo': 'bar', 'abc': '123', 'bar': {'baz': {'key': 'value'}}}),
({'bar': 'test'}, {'foo': 'bar', 'bar': 'test'}),
({'bar': {'test': 'value'}}, {'foo': 'bar', 'bar': {'baz': {'key': 'value'}, 'test': 'value'}}),
({'test': 123}, {'foo': 'bar', 'test': 123, 'bar': {'baz': {'key': 'value'}}}),
({'foo': 123}, {'foo': 123, 'bar': {'baz': {'key': 'value'}}}),
({'bar': 123}, {'foo': 'bar', 'bar': 123}),
({'test': [1, 2, 3]}, {'foo': 'bar', 'test': [1, 2, 3], 'bar': {'baz': {'key': 'value'}}}),
({'foo': [1, 2, 3]}, {'foo': [1, 2, 3], 'bar': {'baz': {'key': 'value'}}}),
({'bar': [1, 2, 3]}, {'foo': 'bar', 'bar': [1, 2, 3]}),
({'test': {'a': 1}}, {'foo': 'bar', 'test': {'a': 1}, 'bar': {'baz': {'key': 'value'}}}),
({'foo': {'a': 1}}, {'foo': {'a': 1}, 'bar': {'baz': {'key': 'value'}}}),
({'bar': {'a': 1}}, {'foo': 'bar', 'bar': {'a': 1, 'baz': {'key': 'value'}}}),
({'test': False}, {'foo': 'bar', 'test': False, 'bar': {'baz': {'key': 'value'}}}),
({'foo': False}, {'foo': False, 'bar': {'baz': {'key': 'value'}}}),
({'bar': False}, {'foo': 'bar', 'bar': False}),
({'test': None}, {'foo': 'bar', 'test': None, 'bar': {'baz': {'key': 'value'}}}),
({'foo': None}, {'foo': None, 'bar': {'baz': {'key': 'value'}}}),
({'bar': None}, {'foo': 'bar', 'bar': None}),
]
)
def test_merge(self, source, expected):
"""Update the DotDict"""
dd = utils.DotDict({
'foo': 'bar',
'bar': {
'baz': {
'key': 'value'
}
}
})
dd.merge(source)
assert dd == expected
def test_deep_merge(self):
"""Test merging through many nested dicts."""
dd = utils.DotDict({
'foo': {
'bar': {
'baz': {
'bison': True
}
}
}
})
dd.merge({'foo': {
'bar': {
'baz': {
'birds': False
}
}
}})
assert dd == {
'foo': {
'bar': {
'baz': {
'bison': True,
'birds': False
}
}
}
}