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))