def _verify_import_path(self, path):
if not os.path.exists(path):
raise DataError('File or directory does not exist.')
if not os.path.isabs(path):
raise DataError('Import path must be absolute.')
if not os.path.splitext(path)[1] in self._valid_import_extensions:
raise DataError('Not a valid file or directory to import.')
def _validate(self, name, value):
if name[0] == '@' and not is_list_like(value):
raise DataError("Invalid variable '%s': Expected list-like value, "
"got %s." % (name, type_name(value)))
if name[0] == '&' and not is_dict_like(value):
raise DataError("Invalid variable '%s': Expected dict-like value, "
"got %s." % (name, type_name(value)))
def _parse_spec(self, path):
if not os.path.isfile(path):
raise DataError("Spec file '%s' does not exist." % path)
with ETSource(path) as source:
root = ET.parse(source).getroot()
if root.tag != 'keywordspec':
raise DataError("Invalid spec file '%s'." % path)
return root
def _validate_log_level_and_default(self, log_level, default):
if log_level not in loggerhelper.LEVELS:
raise DataError("Invalid log level '%s'" % log_level)
if default not in loggerhelper.LEVELS:
raise DataError("Invalid log level '%s'" % default)
if not loggerhelper.IsLogged(log_level)(default):
raise DataError("Default visible log level '%s' is lower than "
"log level '%s'" % (default, log_level))
def _open(self, path):
if not os.path.isfile(path):
raise DataError("Data source does not exist.")
try:
# IronPython handles BOM incorrectly if not using binary mode:
# https://ironpython.codeplex.com/workitem/34655
return open(path, 'rb')
except:
raise DataError(get_error_message())
def _validate_state(self, is_list, is_dict):
if is_list and self._seen_list:
raise DataError('Assignment can contain only one list variable.')
if self._seen_dict or is_dict and self._seen_any_var:
raise DataError('Dictionary variable cannot be assigned with '
'other variables.')
self._seen_list += is_list
self._seen_dict += is_dict
self._seen_any_var = True
def _transform_items(self, items):
try:
items = [self._to_number_with_arithmetics(item) for item in items]
except:
raise DataError('Converting argument of FOR IN RANGE failed: %s.'
% get_error_message())
if not 1 <= len(items) <= 3:
raise DataError('FOR IN RANGE expected 1-3 arguments, got %d.'
% len(items))
return frange(*items)
def _validate(self, data):
if not data.variables:
raise DataError('FOR loop has no loop variables.')
for var in data.variables:
if not is_scalar_var(var):
raise DataError("Invalid FOR loop variable '%s'." % var)
if not data.values:
raise DataError('FOR loop has no loop values.')
if not data.keywords:
raise DataError('FOR loop contains no keywords.')
def _parse_arguments(self, handler_method):
spec = DynamicArgumentParser().parse(self._argspec, self.longname)
if not self._supports_kwargs:
if spec.kwargs:
raise DataError("Too few '%s' method parameters for **kwargs "
"support." % self._run_keyword_method_name)
if spec.kwonlyargs:
raise DataError("Too few '%s' method parameters for "
"keyword-only arguments support."
% self._run_keyword_method_name)
spec.types = GetKeywordTypes(self.library.get_instance())(self._handler_name)
return spec
def _raise_import_failed(self, name, error):
import_type = '%s ' % self._type if self._type else ''
msg = "Importing %s'%s' failed: %s" % (import_type, name,
error.message)
if not error.details:
raise DataError(msg)
msg = [msg, error.details]
msg.extend(self._get_items_in('PYTHONPATH', sys.path))
if JYTHON:
classpath = getProperty('java.class.path').split(os.path.pathsep)
msg.extend(self._get_items_in('CLASSPATH', classpath))
raise DataError('\n'.join(msg))
def gather_failed_tests(output):
if output.upper() == 'NONE':
return []
gatherer = GatherFailedTests()
try:
ExecutionResult(output, include_keywords=False).suite.visit(gatherer)
if not gatherer.tests:
raise DataError('All tests passed.')
except:
raise DataError("Collecting failed tests from '%s' failed: %s" %
(output, get_error_message()))
return gatherer.tests
def _get_handler(self, name):
handler = None
if not name:
raise DataError('Keyword name cannot be empty.')
if not is_string(name):
raise DataError('Keyword name must be a string.')
if '.' in name:
handler = self._get_explicit_handler(name)
if not handler:
handler = self._get_implicit_handler(name)
if not handler:
handler = self._get_bdd_style_handler(name)
return handler
def _get_version(self, listener):
try:
version = int(listener.ROBOT_LISTENER_API_VERSION)
if version not in (2, 3):
raise ValueError
except AttributeError:
raise DataError("Listener '%s' does not have mandatory "
"'ROBOT_LISTENER_API_VERSION' attribute."
% self.name)
except (ValueError, TypeError):
raise DataError("Listener '%s' uses unsupported API version '%s'."
% (self.name, listener.ROBOT_LISTENER_API_VERSION))
return version
def _get_runner(self, name):
if not name:
raise DataError('Keyword name cannot be empty.')
if not is_string(name):
raise DataError('Keyword name must be a string.')
runner = self._get_runner_from_test_case_file(name)
if not runner and '.' in name:
runner = self._get_explicit_runner(name)
if not runner:
runner = self._get_implicit_runner(name)
if not runner:
runner = self._get_bdd_style_runner(name)
return runner
def _raise_no_single_match(self, name, found):
if self._source is None:
where = "Test case file"
elif self._is_resource(self._source):
where = "Resource file '%s'" % self._source
else:
where = "Test library '%s'" % self._source
if not found:
raise DataError("%s contains no keywords matching name '%s'."
% (where, name))
error = ["%s contains multiple keywords matching name '%s':"
% (where, name)]
names = sorted(handler.orig_name for handler in found)
raise DataError('\n '.join(error + names))
def _get_escapes(self, escape_strings):
escapes = {}
for estr in escape_strings:
try:
name, value = estr.split(':', 1)
except ValueError:
raise DataError("Invalid escape string syntax '%s'. "
"Expected: what:with" % estr)
try:
escapes[value] = ESCAPES[name.lower()]
except KeyError:
raise DataError("Invalid escape '%s'. Available: %s" %
(name, self._get_available_escapes()))
return escapes
def gather_failed_tests(output):
if output.upper() == 'NONE':
return []
gatherer = GatherFailedTests()
tests_or_tasks = 'tests or tasks'
try:
suite = ExecutionResult(output, include_keywords=False).suite
suite.visit(gatherer)
tests_or_tasks = 'tests' if not suite.rpa else 'tasks'
if not gatherer.tests:
raise DataError('All %s passed.' % tests_or_tasks)
except:
raise DataError("Collecting failed %s from '%s' failed: %s" %
(tests_or_tasks, output, get_error_message()))
return gatherer.tests
def _process_report_background(self, colors):
if colors.count(':') not in [1, 2]:
raise DataError("Invalid report background colors '%s'." % colors)
colors = colors.split(':')
if len(colors) == 2:
return colors[0], colors[0], colors[1]
return tuple(colors)
def _create_output_dir(self, path, type_):
try:
if not os.path.exists(path):
os.makedirs(path)
except EnvironmentError as err:
raise DataError("Creating %s file directory '%s' failed: %s"
% (type_.lower(), path, err.strerror))
def _raise_no_keyword_found(self, name):
msg = "No keyword with name '%s' found." % name
finder = KeywordRecommendationFinder(self.user_keywords,
self.libraries, self.resources)
recommendations = finder.recommend_similar_keywords(name)
msg = finder.format_recommendations(msg, recommendations)
raise DataError(msg)
def convert_type_list_to_dict(self, types):
names = self._argspec.argument_names
if len(types) > len(names):
raise DataError('Type information given to %d argument%s but '
'keyword has only %d argument%s.'
% (len(types), s(types), len(names), s(names)))
return {name: value for name, value in zip(names, types) if value}
def validate_flatten_keyword(options):
for opt in options:
low = opt.lower()
if not (low in ('for', 'foritem') or low.startswith('name:')
or low.startswith('tag:')):
raise DataError("Expected 'FOR', 'FORITEM', 'TAG:<pattern>', or "
"'NAME:<pattern>' but got '%s'." % opt)
def set_test(self, name, value):
if self._test is None:
raise DataError(
'Cannot set test variable when no test is started.')
for scope in self._scopes_until_test:
name, value = self._set_global_suite_or_test(scope, name, value)
self._variables_set.set_test(name, value)
def _find_resource_file(self, path):
if os.path.isfile(path):
return path
for dire in [item for item in sys.path if os.path.isdir(item)]:
if os.path.isfile(os.path.join(dire, path)):
return os.path.join(dire, path)
raise DataError("Resource file '%s' does not exist." % path)
def _validate_no_extra_named(self, named, spec):
if not spec.kwargs:
extra = set(named) - set(spec.positional) - set(spec.kwonlyargs)
if extra:
raise DataError("%s '%s' got unexpected named argument%s %s." %
(spec.type, spec.name, plural_or_not(extra),
seq2str(sorted(extra))))
def _validate_no_named_only_missing(self, named, spec):
defined = set(named) | set(spec.defaults)
missing = [arg for arg in spec.kwonlyargs if arg not in defined]
if missing:
raise DataError("%s '%s' missing named-only argument%s %s." %
(spec.type, spec.name, plural_or_not(missing),
seq2str(sorted(missing))))
def _get_level_and_html(self, level, html):
level = level.upper()
if level == 'HTML':
return 'INFO', True
if level not in LEVELS:
raise DataError("Invalid log level '%s'." % level)
return level, html
def _parse_args(self, args):
args = [self._lowercase_long_option(a) for a in args]
try:
opts, args = getopt.getopt(args, self._short_opts, self._long_opts)
except getopt.GetoptError as err:
raise DataError(err.msg)
return self._process_opts(opts), self._glob_args(args)
def _parse(self, path):
try:
return TestData(source=abspath(path),
include_suites=self.include_suites,
warn_on_skipped=self.warn_on_skipped)
except DataError as err:
raise DataError("Parsing '%s' failed: %s" % (path, unicode(err)))
def _read_from_file(self, path):
try:
with Utf8Reader(path) as reader:
return reader.read()
except (IOError, UnicodeError) as err:
raise DataError("Opening argument file '%s' failed: %s" %
(path, err))
