def test_resolver_resolve_expression(patch):
patch.object(Resolver, 'expression')
item = {'$OBJECT': 'expression', 'expression': '==', 'values': []}
result = Resolver.resolve(item, 'data')
Resolver.expression.assert_called_with('data', item['expression'],
item['values'])
assert result == Resolver.expression()
def test_resolver_object_method(patch):
patch.object(Resolver, 'method')
patch.object(Resolver, 'handside', return_value='hand')
item = {
'$OBJECT': 'method',
'method': 'method',
'left': 'left',
'right': 'right'
}
result = Resolver.object(item, 'data')
Resolver.method.assert_called_with('method', 'hand', 'hand')
assert result == Resolver.method()
def test_resolver_expression(patch):
patch.object(Resolver, 'values', return_value=[1])
patch.object(Resolver, 'stringify', return_value='1')
result = Resolver.expression('data', '{} == 1', 'values')
Resolver.values.assert_called_with('values', data='data')
Resolver.stringify.assert_called_with(1)
assert result
def test_resolver_values():
values = [{
'$OBJECT': 'path',
'paths': ['one']
}, {
'$OBJECT': 'path',
'paths': ['two']
}]
assert Resolver.values(values, {'one': 1, 'two': 2}) == [1, 2]
def test_resolver_object_str_str():
items = [[{
'$OBJECT': 'string',
'string': 'example'
}, {
'$OBJECT': 'string',
'string': 'data'
}]]
assert dict(Resolver.dict(items, {})) == {'example': 'data'}
def test_resolver_object_path_path():
items = [[{
'$OBJECT': 'path',
'paths': ['a']
}, {
'$OBJECT': 'path',
'paths': ['b']
}]]
data = {'a': 'example', 'b': 'data'}
assert dict(Resolver.dict(items, data)) == {'example': 'data'}
def test_resolve_many():
result = Resolver.resolve(
{
'$OBJECT': 'string',
'string': '{}',
'values': [{
'$OBJECT': 'path',
'paths': ['foo', 'bar']
}]
}, {'foo': {
'bar': 'data'
}})
assert result == 'data'
def test_resolver_path_list():
path = ['a', '1', 'b']
data = {'a': [None, {'b': 'value'}]}
assert Resolver.path(path, data) == 'value'
def test_resolver_path():
path = ['a', 'b', 'c']
data = {'a': {'b': {'c': 'value'}}}
assert Resolver.path(path, data) == 'value'
def test_resolver_handside(patch):
patch.object(Resolver, 'object')
result = Resolver.handside('item', 'data')
Resolver.object.assert_called_with('item', 'data')
assert result == Resolver.object()
def test_resolver_object_file_values(patch):
patch.object(Resolver, 'file')
item = {'$OBJECT': 'file', 'string': 'filename', 'values': ['values']}
result = Resolver.object(item, 'data')
Resolver.file.assert_called_with(item['string'], 'data', values=['values'])
assert result == Resolver.file()
def test_resolver_list_booleans(patch):
patch.object(Resolver, 'resolve', return_value=True)
result = Resolver.list(['items'], {})
Resolver.resolve.assert_called_with('items', {})
assert result == [True]
def test_resolve_method(method, left, right, result):
assert Resolver.method(method, left, right) == result
def test_resolve_dict(dictionary, data, result):
assert Resolver.dictionary(dictionary, data) == result
def test_resolver_string():
assert Resolver.string('hello', {}) == 'hello'
def test_resolver_resolve_list(patch):
patch.object(Resolver, 'list')
result = Resolver.resolve([], 'data')
Resolver.list.assert_called_with([], 'data')
assert result == Resolver.list()
def test_resolver_resolve_object(patch):
patch.object(Resolver, 'object')
result = Resolver.resolve({}, 'data')
Resolver.object.assert_called_with({}, 'data')
assert result == Resolver.object()
def test_resolver_resolve(patch):
assert Resolver.resolve('whatever', 'data') == 'whatever'
def test_resolver_path_key_error():
assert Resolver.path(['a', 'b'], {}) is None
def test_resolve_path(path, data, result):
assert Resolver.path(path, data) == result
def test_resolver_dictionary(patch):
patch.object(Resolver, 'resolve')
result = Resolver.dictionary({'key': 'value'}, 'data')
Resolver.resolve.assert_called_with('value', 'data')
assert result == {'key': Resolver.resolve()}
def test_resolve_resolve(obj, data, result):
assert Resolver.resolve(obj, data) == result
def test_resolve_list(items_list, data, result):
assert Resolver.values(items_list, data=data) == result
def test_resolver_list(patch):
patch.object(Resolver, 'resolve', return_value='done')
result = Resolver.list(['items'], {})
Resolver.resolve.assert_called_with('items', {})
assert result == 'done'
def test_stringify(value, result):
assert Resolver.stringify(value) == result
def test_resolver_file():
assert Resolver.file('filename', {}) == 'filename'
def test_resolve_path_undefined():
assert Resolver.path('a.b', {}) is None
def test_resolver_file_values(patch):
patch.object(Resolver, 'values', return_value=['a'])
result = Resolver.file('{}.py', {}, values=['values'])
Resolver.values.assert_called_with(['values'], {})
assert result == 'a.py'
def test_resolve_obj_regexp():
result = Resolver.object({'$OBJECT': 'regexp', 'regexp': 'abc'}, None)
assert result.pattern == 'abc'
def test_resolver_argument(patch):
patch.object(Resolver, 'object')
result = Resolver.argument('argument', {})
Resolver.object.assert_called_with('argument', {})
assert result == Resolver.object()
