def test_objects_values_filepath(patch, magic):
patch.object(Objects, 'file')
item = magic(type='FILEPATH')
tree = magic(child=lambda x: item)
result = Objects.values(tree)
Objects.file.assert_called_with(item)
assert result == Objects.file()
def test_objects_typed_argument(patch, tree):
patch.object(Objects, 'values')
result = Objects.typed_argument(tree)
Objects.values.assert_called_with(Tree('anon', [tree.child(1)]))
expected = {'$OBJECT': 'argument', 'name': tree.child().value,
'argument': Objects.values()}
assert result == expected
def test_objects_string(patch, tree):
patch.object(Objects, 'unescape_string')
patch.object(re, 'findall', return_value=[])
result = Objects.string(tree)
Objects.unescape_string.assert_called_with(tree)
re.findall.assert_called_with(r'{([^}]*)}', Objects.unescape_string())
assert result == {'$OBJECT': 'string', 'string': Objects.unescape_string()}
def test_objects_expression(patch, tree):
patch.object(Objects, 'values')
tree.child.return_value = None
tree.values = None
result = Objects.expression(tree)
Objects.values.assert_called_with(tree.path_value.child())
assert result == [Objects.values()]
def test_compiler_assignment_parent(patch, compiler, tree):
patch.many(Objects, ['path', 'values'])
patch.object(Compiler, 'add_line')
compiler.assignment(tree, parent='1')
args = [Objects.path(), Objects.values()]
compiler.add_line.assert_called_with('set', tree.line(), args=args,
parent='1')
def test_objects_function_arguments(patch, tree):
patch.object(Objects, 'typed_argument')
tree.find_data.return_value = ['typed_argument']
result = Objects.function_arguments(tree)
tree.find_data.assert_called_with('typed_argument')
Objects.typed_argument.assert_called_with('typed_argument')
assert result == [Objects.typed_argument()]
def test_objects_values_path(patch, magic):
patch.object(Objects, 'path')
item = magic(type='NAME')
tree = magic(child=lambda x: item)
result = Objects.values(tree)
Objects.path.assert_called_with(tree)
assert result == Objects.path()
def test_objects_values_method(patch, magic):
patch.object(Objects, 'method')
item = magic(data='path')
tree = magic(child=lambda x: item)
result = Objects.values(tree)
Objects.method.assert_called_with(tree)
assert result == Objects.method()
def test_objects_arguments(patch, tree):
patch.object(Objects, 'argument')
tree.find_data.return_value = filter(lambda x: x, ['argument'])
result = Objects.arguments(tree)
tree.find_data.assert_called_with('arguments')
Objects.argument.assert_called_with('argument')
assert result == [Objects.argument()]
def test_objects_absolute_expression(patch, tree):
"""
Ensures Objects.absolute_expression calls expression
"""
patch.many(Objects, ['expression'])
tree.child(0).data = 'expression'
Objects.absolute_expression(tree)
Objects.expression.assert_called_with(tree.child(0))
def test_objects_resolve_operand_sum_to_parenthesis(patch, tree):
"""
Ensures resolve_operand can resolve a parenthesis operand
"""
patch.object(Objects, 'expression')
result = Objects.resolve_operand(tree)
Objects.expression.assert_called_with(tree.exponential.factor.expression)
assert result == Objects.expression()
def test_objects_argument(patch, tree):
patch.object(Objects, 'expression')
result = Objects.argument(tree)
assert tree.child.call_count == 2
Objects.expression.assert_called_with(tree.child())
expected = {'$OBJECT': 'argument', 'name': tree.child().value,
'argument': Objects.expression()}
assert result == expected
def test_objects_resolve_operand_multiplication_to_parenthesis(patch, tree):
"""
Ensures resolve_operand can resolve a multiplication to a parenthesis.
"""
patch.object(Objects, 'expression')
tree.exponential = None
result = Objects.resolve_operand(tree)
Objects.expression.assert_called_with(tree.factor.expression)
assert result == Objects.expression()
def test_objects_resolve_operand_number(patch, tree):
"""
Ensures resolve_operand can resolve a number.
"""
patch.object(Objects, 'number')
tree.data = 'number'
result = Objects.resolve_operand(tree)
Objects.number.assert_called_with(tree)
assert result == Objects.number()
def test_objects_names_string(patch, magic, tree):
"""
Ensures that paths like x['y'] are compiled correctly
"""
patch.object(Objects, 'string')
tree.children = [magic(), Tree('fragment', [Tree('string', 'token')])]
result = Objects.names(tree)
Objects.string.assert_called_with(Tree('string', 'token'))
assert result[1] == Objects.string()
def test_compiler_mutation_block_nested(patch, compiler, lines, tree):
patch.many(Objects, ['entity', 'mutation'])
patch.object(Compiler, 'chained_mutations', return_value=['chained'])
tree.path = None
compiler.mutation_block(tree, None)
Compiler.chained_mutations.assert_called_with(tree.nested_block)
args = [Objects.entity(), Objects.mutation(), 'chained', 'chained']
kwargs = {'args': args, 'parent': None}
lines.append.assert_called_with('mutation', tree.line(), **kwargs)
def test_objects_string_templating(patch):
patch.object(Objects, 'path')
patch.object(re, 'findall', return_value=['color'])
tree = Tree('string', [Token('DOUBLE_QUOTED', '"{{color}}"')])
result = Objects.string(tree)
re.findall.assert_called_with(r'{{([^}]*)}}', '{{color}}')
Objects.path.assert_called_with(Tree('path', [Token('WORD', 'color')]))
assert result['string'] == '{}'
assert result['values'] == [Objects.path()]
def test_objects_typed_argument(patch, tree):
patch.object(Objects, 'values')
result = Objects.typed_argument(tree)
expected = {
'$OBJECT': 'argument',
'name': tree.node().child().value,
'argument': Objects.values()
}
assert result == expected
def test_objects_resolve_operand_multiplication(patch, tree):
"""
Ensures resolve_operand can resolve a multiplication tree.
"""
patch.object(Objects, 'entity')
tree.exponential.factor.expression = None
result = Objects.resolve_operand(tree)
Objects.entity.assert_called_with(tree.exponential.factor.entity)
assert result == Objects.entity()
def test_objects_resolve_operand_exponential(patch, magic, tree):
"""
Ensures resolve_operand can resolve an exponential tree
"""
patch.object(Objects, 'expression')
tree.exponential.children = [1, 2]
result = Objects.resolve_operand(tree)
Objects.expression.assert_called_with(tree.exponential)
assert result == Objects.expression()
def test_objects_assertion_single_entity(patch, tree):
"""
Ensures that Objects.assertion handles single entities
"""
patch.many(Objects, ['expression'])
Objects.expression.return_value = True
result = Objects.assertion(tree)
Objects.expression.assert_called_with(tree.expression)
assert result == [Objects.expression()]
def test_objects_objects_key_path(patch, tree):
"""
Ensures that objects like {x: 0} are compiled
"""
patch.many(Objects, ['path', 'expression'])
subtree = Tree('key_value', [Tree('path', ['path'])])
tree.children = [subtree]
result = Objects.objects(tree)
assert result['items'][0][0] == Objects.path()
def test_objects_resolve_operand_children(patch, tree):
"""
Ensures resolve_operand can resolve nested operands.
"""
patch.object(Objects, 'expression')
tree.children = [1, 2]
result = Objects.resolve_operand(tree)
Objects.expression.assert_called_with(tree)
assert result == Objects.expression()
def test_objects_mutation_arguments(patch, magic):
"""
Ensures that mutations objects with arguments are compiled correctly.
"""
patch.object(Objects, 'arguments')
tree = magic()
result = Objects.mutation(tree)
Objects.arguments.assert_called_with(tree)
assert result['arguments'] == Objects.arguments()
def test_objects_primary_expression_two(patch, tree):
"""
Ensures Objects.primary_expression works with a or_expression node
"""
patch.many(Objects, ['entity', 'or_expression'])
tree.child(0).data = 'or_expression'
r = Objects.primary_expression(tree)
Objects.or_expression.assert_called_with(tree.child(0))
assert r == Objects.or_expression()
def test_objects_primary_expression_entity(patch, tree):
"""
Ensures Objects.primary_expression works with an entity node
"""
patch.many(Objects, ['entity'])
tree.child(0).data = 'entity'
r = Objects.primary_expression(tree)
Objects.entity.assert_called_with(tree.entity)
assert r == Objects.entity()
def test_objects_number():
"""
Ensures that an int is compiled correctly.
"""
tree = Tree('number', [Token('INT', '1')])
assert Objects.number(tree) == 1
tree = Tree('number', [Token('INT', '+1')])
assert Objects.number(tree) == 1
tree = Tree('number', [Token('INT', '-1')])
assert Objects.number(tree) == -1
def test_objects_cmp_expression_one(patch, tree):
"""
Ensures Objects.and_expression works with one node
"""
patch.many(Objects, ['arith_expression'])
tree.child(0).data = 'arith_expression'
tree.children = [1]
r = Objects.cmp_expression(tree)
Objects.arith_expression.assert_called_with(tree.child(0))
assert r == Objects.arith_expression()
def test_objects_pow_expression_one(patch, tree):
"""
Ensures Objects.pow_expression works with one node
"""
patch.many(Objects, ['primary_expression'])
tree.child(0).data = 'primary_expression'
tree.children = [1]
r = Objects.pow_expression(tree)
Objects.primary_expression.assert_called_with(tree.child(0))
assert r == Objects.primary_expression()
def test_objects_names_path(patch, magic, tree):
"""
Ensures that paths like x[y] are compiled correctly
"""
patch.object(Objects, 'path')
subtree = Tree('path', ['token'])
tree.children = [magic(), Tree('fragment', [subtree])]
result = Objects.names(tree)
Objects.path.assert_called_with(subtree)
assert result[1] == Objects.path()
