# Copyright 2008-2015 Nokia Networks
# Copyright 2016- Robot Framework Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ast import NodeVisitor
from robot.errors import DataError
from robot.output import LOGGER
from robot.parsing import File, Token
from robot.variables import VariableIterator
from .settings import FileSettings
from ..model import ResourceFile, TestSuite
[docs]class SettingsBuilder(NodeVisitor):
def __init__(self, suite: TestSuite, settings: FileSettings):
self.suite = suite
self.settings = settings
[docs] def visit_Documentation(self, node):
self.suite.doc = node.value
[docs] def visit_SuiteName(self, node):
self.suite.name = node.value
[docs] def visit_SuiteSetup(self, node):
self.suite.setup.config(name=node.name, args=node.args,
lineno=node.lineno)
[docs] def visit_SuiteTeardown(self, node):
self.suite.teardown.config(name=node.name, args=node.args,
lineno=node.lineno)
[docs] def visit_TestSetup(self, node):
self.settings.test_setup = {'name': node.name, 'args': node.args,
'lineno': node.lineno}
[docs] def visit_TestTeardown(self, node):
self.settings.test_teardown = {'name': node.name, 'args': node.args,
'lineno': node.lineno}
[docs] def visit_TestTimeout(self, node):
self.settings.test_timeout = node.value
[docs] def visit_TestTemplate(self, node):
self.settings.test_template = node.value
[docs] def visit_LibraryImport(self, node):
self.suite.resource.imports.library(node.name, node.args, node.alias, node.lineno)
[docs] def visit_ResourceImport(self, node):
self.suite.resource.imports.resource(node.name, node.lineno)
[docs] def visit_VariablesImport(self, node):
self.suite.resource.imports.variables(node.name, node.args, node.lineno)
[docs] def visit_VariableSection(self, node):
pass
[docs] def visit_TestCaseSection(self, node):
pass
[docs] def visit_KeywordSection(self, node):
pass
[docs]class SuiteBuilder(NodeVisitor):
def __init__(self, suite: TestSuite, settings: FileSettings):
self.suite = suite
self.settings = settings
self.rpa = None
[docs] def build(self, model: File):
ErrorReporter(model.source).visit(model)
SettingsBuilder(self.suite, self.settings).visit(model)
self.visit(model)
if self.rpa is not None:
self.suite.rpa = self.rpa
[docs] def visit_SettingSection(self, node):
pass
[docs] def visit_Variable(self, node):
self.suite.resource.variables.create(name=node.name,
value=node.value,
lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_TestCaseSection(self, node):
if self.rpa is None:
self.rpa = node.tasks
elif self.rpa != node.tasks:
raise DataError('One file cannot have both tests and tasks.')
self.generic_visit(node)
[docs] def visit_TestCase(self, node):
TestCaseBuilder(self.suite, self.settings).visit(node)
[docs] def visit_Keyword(self, node):
KeywordBuilder(self.suite.resource, self.settings).visit(node)
[docs]class ResourceBuilder(NodeVisitor):
def __init__(self, resource: ResourceFile):
self.resource = resource
self.settings = FileSettings()
[docs] def build(self, model: File):
ErrorReporter(model.source, raise_on_invalid_header=True).visit(model)
self.visit(model)
[docs] def visit_Documentation(self, node):
self.resource.doc = node.value
[docs] def visit_LibraryImport(self, node):
self.resource.imports.library(node.name, node.args, node.alias, node.lineno)
[docs] def visit_ResourceImport(self, node):
self.resource.imports.resource(node.name, node.lineno)
[docs] def visit_VariablesImport(self, node):
self.resource.imports.variables(node.name, node.args, node.lineno)
[docs] def visit_Variable(self, node):
self.resource.variables.create(name=node.name,
value=node.value,
lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Keyword(self, node):
KeywordBuilder(self.resource, self.settings).visit(node)
[docs]class TestCaseBuilder(NodeVisitor):
def __init__(self, suite: TestSuite, settings: FileSettings):
self.suite = suite
self.settings = settings
self.test = None
self.tags = None
[docs] def visit_TestCase(self, node):
error = format_error(node.errors + node.header.errors)
settings = self.settings
self.test = self.suite.tests.create(name=node.name,
lineno=node.lineno,
tags=settings.test_tags,
timeout=settings.test_timeout,
template=settings.test_template,
error=error)
if settings.test_setup:
self.test.setup.config(**settings.test_setup)
if settings.test_teardown:
self.test.teardown.config(**settings.test_teardown)
self.generic_visit(node)
tags = self.tags if self.tags is not None else settings.default_tags
if tags:
self.test.tags.add(tags)
if self.test.template:
self._set_template(self.test, self.test.template)
def _set_template(self, parent, template):
for item in parent.body:
if item.type == item.FOR:
self._set_template(item, template)
elif item.type == item.IF_ELSE_ROOT:
for branch in item.body:
self._set_template(branch, template)
elif item.type == item.KEYWORD:
name, args = self._format_template(template, item.args)
item.name = name
item.args = args
def _format_template(self, template, arguments):
variables = VariableIterator(template, identifiers='$')
count = len(variables)
if count == 0 or count != len(arguments):
return template, arguments
temp = []
for (before, _, after), arg in zip(variables, arguments):
temp.extend([before, arg])
temp.append(after)
return ''.join(temp), ()
[docs] def visit_For(self, node):
ForBuilder(self.test).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.test).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.test).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.test).build(node)
[docs] def visit_TemplateArguments(self, node):
self.test.body.create_keyword(args=node.args, lineno=node.lineno)
[docs] def visit_Documentation(self, node):
self.test.doc = node.value
[docs] def visit_Setup(self, node):
self.test.setup.config(name=node.name, args=node.args, lineno=node.lineno)
[docs] def visit_Teardown(self, node):
self.test.teardown.config(name=node.name, args=node.args, lineno=node.lineno)
[docs] def visit_Timeout(self, node):
self.test.timeout = node.value
[docs] def visit_Template(self, node):
self.test.template = node.value
[docs] def visit_KeywordCall(self, node):
self.test.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_ReturnStatement(self, node):
self.test.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.test.body.create_continue(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.test.body.create_break(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Error(self, node):
self.test.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class KeywordBuilder(NodeVisitor):
def __init__(self, resource: ResourceFile, settings: FileSettings):
self.resource = resource
self.settings = settings
self.kw = None
[docs] def visit_Keyword(self, node):
error = format_error(node.errors + node.header.errors)
self.kw = self.resource.keywords.create(name=node.name,
tags=self.settings.keyword_tags,
lineno=node.lineno,
error=error)
self.generic_visit(node)
[docs] def visit_Documentation(self, node):
self.kw.doc = node.value
[docs] def visit_Arguments(self, node):
self.kw.args = node.values
if node.errors:
error = format_error(node.errors)
self.kw.error = f'Invalid argument specification: {error}'
[docs] def visit_Return(self, node):
self.kw.return_ = node.values
[docs] def visit_Timeout(self, node):
self.kw.timeout = node.value
[docs] def visit_Teardown(self, node):
self.kw.teardown.config(name=node.name, args=node.args,
lineno=node.lineno)
[docs] def visit_KeywordCall(self, node):
self.kw.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_ReturnStatement(self, node):
self.kw.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.kw.body.create_continue(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.kw.body.create_break(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_For(self, node):
ForBuilder(self.kw).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.kw).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.kw).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.kw).build(node)
[docs] def visit_Error(self, node):
self.kw.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class ForBuilder(NodeVisitor):
def __init__(self, parent):
self.parent = parent
self.model = None
[docs] def build(self, node):
error = format_error(self._get_errors(node))
self.model = self.parent.body.create_for(
node.variables, node.flavor, node.values, node.start, node.mode, node.fill,
lineno=node.lineno, error=error
)
for step in node.body:
self.visit(step)
return self.model
def _get_errors(self, node):
errors = node.header.errors + node.errors
if node.end:
errors += node.end.errors
return errors
[docs] def visit_KeywordCall(self, node):
self.model.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_TemplateArguments(self, node):
self.model.body.create_keyword(args=node.args, lineno=node.lineno)
[docs] def visit_For(self, node):
ForBuilder(self.model).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.model).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.model).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.model).build(node)
[docs] def visit_ReturnStatement(self, node):
self.model.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.model.body.create_continue(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.model.body.create_break(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Error(self, node):
self.model.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class IfBuilder(NodeVisitor):
def __init__(self, parent):
self.parent = parent
self.model = None
[docs] def build(self, node):
root = self.parent.body.create_if(lineno=node.lineno,
error=format_error(self._get_errors(node)))
assign = node.assign
node_type = None
while node:
node_type = node.type if node.type != 'INLINE IF' else 'IF'
self.model = root.body.create_branch(node_type, node.condition,
lineno=node.lineno)
for step in node.body:
self.visit(step)
if assign:
for item in self.model.body:
# Having assign when model item doesn't support assign is an error,
# but it has been handled already when model was validated.
if hasattr(item, 'assign'):
item.assign = assign
node = node.orelse
# Smallish hack to make sure assignment is always run.
if assign and node_type != 'ELSE':
root.body.create_branch('ELSE').body.create_keyword(
assign=assign, name='BuiltIn.Set Variable', args=['${NONE}']
)
return root
def _get_errors(self, node):
errors = node.header.errors + node.errors
if node.orelse:
errors += self._get_errors(node.orelse)
if node.end:
errors += node.end.errors
return errors
[docs] def visit_KeywordCall(self, node):
self.model.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_TemplateArguments(self, node):
self.model.body.create_keyword(args=node.args, lineno=node.lineno)
[docs] def visit_For(self, node):
ForBuilder(self.model).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.model).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.model).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.model).build(node)
[docs] def visit_ReturnStatement(self, node):
self.model.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.model.body.create_continue(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.model.body.create_break(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Error(self, node):
self.model.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class TryBuilder(NodeVisitor):
def __init__(self, parent):
self.parent = parent
self.model = None
self.template_error = None
[docs] def build(self, node):
root = self.parent.body.create_try(lineno=node.lineno)
errors = self._get_errors(node)
while node:
self.model = root.body.create_branch(node.type, node.patterns,
node.pattern_type, node.variable,
lineno=node.lineno)
for step in node.body:
self.visit(step)
node = node.next
if self.template_error:
errors += (self.template_error,)
if errors:
root.error = format_error(errors)
return root
def _get_errors(self, node):
errors = node.header.errors + node.errors
if node.next:
errors += self._get_errors(node.next)
if node.end:
errors += node.end.errors
return errors
[docs] def visit_For(self, node):
ForBuilder(self.model).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.model).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.model).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.model).build(node)
[docs] def visit_ReturnStatement(self, node):
self.model.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.model.body.create_continue(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.model.body.create_break(lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_KeywordCall(self, node):
self.model.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_TemplateArguments(self, node):
self.template_error = 'Templates cannot be used with TRY.'
[docs] def visit_Error(self, node):
self.model.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class WhileBuilder(NodeVisitor):
def __init__(self, parent):
self.parent = parent
self.model = None
[docs] def build(self, node):
error = format_error(self._get_errors(node))
self.model = self.parent.body.create_while(
node.condition, node.limit, node.on_limit,
node.on_limit_message, lineno=node.lineno, error=error
)
for step in node.body:
self.visit(step)
return self.model
def _get_errors(self, node):
errors = node.header.errors + node.errors
if node.end:
errors += node.end.errors
return errors
[docs] def visit_KeywordCall(self, node):
self.model.body.create_keyword(name=node.keyword, args=node.args,
assign=node.assign, lineno=node.lineno)
[docs] def visit_TemplateArguments(self, node):
self.model.body.create_keyword(args=node.args, lineno=node.lineno)
[docs] def visit_For(self, node):
ForBuilder(self.model).build(node)
[docs] def visit_While(self, node):
WhileBuilder(self.model).build(node)
[docs] def visit_If(self, node):
IfBuilder(self.model).build(node)
[docs] def visit_Try(self, node):
TryBuilder(self.model).build(node)
[docs] def visit_ReturnStatement(self, node):
self.model.body.create_return(node.values, lineno=node.lineno,
error=format_error(node.errors))
[docs] def visit_Break(self, node):
self.model.body.create_break(error=format_error(node.errors))
[docs] def visit_Continue(self, node):
self.model.body.create_continue(error=format_error(node.errors))
[docs] def visit_Error(self, node):
self.model.body.create_error(lineno=node.lineno,
values=node.values, error=format_error(node.errors))
[docs]class ErrorReporter(NodeVisitor):
def __init__(self, source, raise_on_invalid_header=False):
self.source = source
self.raise_on_invalid_header = raise_on_invalid_header
[docs] def visit_TestCase(self, node):
pass
[docs] def visit_Keyword(self, node):
pass
[docs] def visit_Error(self, node):
for error in node.get_tokens(Token.ERROR):
LOGGER.error(self._format_message(error))
def _format_message(self, token):
return f"Error in file '{self.source}' on line {token.lineno}: {token.error}"