def import_resource(self, path):
if self._resources.has_key(path):
LOGGER.info("Found resource file '%s' from cache" % path)
else:
resource = ResourceFile(path)
self._resources[path] = resource
return self._resources[path]
def main(self, datasources, **options):
settings = RobotSettings(options)
LOGGER.register_console_logger(**settings.console_output_config)
LOGGER.info('Settings:\n%s' % unic(settings))
builder = TestSuiteBuilder(settings['SuiteNames'],
extension=settings.extension,
rpa=settings.rpa)
suite = builder.build(*datasources)
settings.rpa = builder.rpa
suite.configure(**settings.suite_config)
if settings.pre_run_modifiers:
suite.visit(ModelModifier(settings.pre_run_modifiers,
settings.run_empty_suite, LOGGER))
with pyloggingconf.robot_handler_enabled(settings.log_level):
old_max_error_lines = text.MAX_ERROR_LINES
text.MAX_ERROR_LINES = settings.max_error_lines
try:
result = suite.run(settings)
finally:
text.MAX_ERROR_LINES = old_max_error_lines
LOGGER.info("Tests execution ended. Statistics:\n%s"
% result.suite.stat_message)
if settings.log or settings.report or settings.xunit:
writer = ResultWriter(settings.output if settings.log
else result)
writer.write_results(settings.get_rebot_settings())
return result.return_code
def import_resource(self, path):
if path in self._resource_cache:
LOGGER.info("Found resource file '%s' from cache" % path)
else:
resource = ResourceFile(path).populate()
self._resource_cache[path] = resource
return self._resource_cache[path]
def filter_empty_suites(self):
for suite in self.suites[:]:
suite.filter_empty_suites()
if suite.get_test_count() == 0:
self.suites.remove(suite)
LOGGER.info("Running test suite '%s' failed: Test suite "
"contains no test cases." % suite.source)
def _get_multisource_suite(datasources, include_suites):
suitedatas = []
for datasource in datasources:
try:
suitedatas.append(_parse_suite(datasource, include_suites))
except DataError, err:
LOGGER.info(err)
def import_resource(self, path):
if path in self._resource_cache:
LOGGER.info("Found resource file '%s' from cache" % path)
else:
resource = ResourceFileBuilder().build(path)
self._resource_cache[path] = resource
return self._resource_cache[path]
def _log_imported_library(self, name, args, lib):
type = lib.__class__.__name__.replace('Library', '').lower()[1:]
LOGGER.info("Imported library '%s' with arguments %s "
"(version %s, %s type, %s scope, %d keywords)"
% (name, utils.seq2str2(args), lib.version or '<unknown>',
type, lib.scope.lower(), len(lib)))
if not lib:
LOGGER.warn("Imported library '%s' contains no keywords" % name)
def __init__(self, variables, suite, resource):
LOGGER.info("Initializing namespace for test suite '%s'" % suite.longname)
self.variables = variables
self._imports = resource.imports
self._kw_store = KeywordStore(resource)
self._imported_variable_files = ImportCache()
self._suite_name = suite.longname
self._running_test = False
def populate(self, path, datadir, include_suites=None, warn_on_skipped=False, recurse=True):
LOGGER.info("Parsing test data directory '%s'" % path)
include_suites = self._get_include_suites(path, include_suites or [])
init_file, children = self._get_children(path, include_suites)
if init_file:
self._populate_init_file(datadir, init_file)
if recurse:
self._populate_children(datadir, children, include_suites, warn_on_skipped)
def import_library(self, name, args, alias, variables):
lib = TestLibrary(name, args, variables, create_handlers=False)
positional, named = lib.positional_args, lib.named_args
lib = self._import_library(name, positional, named, lib)
if alias and name != alias:
lib = self._copy_library(lib, alias)
LOGGER.info("Imported library '%s' with name '%s'" % (name, alias))
return lib
def _populate_children(self, datadir, children, include_extensions,
include_suites):
for child in children:
try:
datadir.add_child(child, include_suites, include_extensions)
except NoTestsFound:
LOGGER.info("Data source '%s' has no tests or tasks." % child)
except DataError as err:
LOGGER.error("Parsing '%s' failed: %s" % (child, err.message))
def populate(self, path):
LOGGER.info("Parsing file '%s'." % path)
source = self._open(path)
try:
self._get_reader(path).read(source, self)
except:
raise DataError(get_error_message())
finally:
source.close()
def __call__(self, signum, frame):
self._signal_count += 1
LOGGER.info('Received signal: %s.' % signum)
if self._signal_count > 1:
sys.__stderr__.write('Execution forcefully stopped.')
raise SystemExit()
sys.__stderr__.write('Second signal will force exit.')
if self._running_keyword and not sys.platform.startswith('java'):
self._stop_execution_gracefully()
def __init__(self, variables, suite, user_keywords, imports):
LOGGER.info("Initializing namespace for test suite '%s'" % suite.longname)
self.suite = suite
self.test = None
self.uk_handlers = []
self.variables = variables
self._imports = imports
self._kw_store = KeywordStore(user_keywords, suite.source)
self._imported_variable_files = ImportCache()
def _log_imported_library(self, name, args, lib):
type = lib.__class__.__name__.replace('Library', '').lower()[1:]
listener = ', with listener' if lib.has_listener else ''
LOGGER.info("Imported library '%s' with arguments %s "
"(version %s, %s type, %s scope, %d keywords%s)"
% (name, seq2str2(args), lib.version or '<unknown>',
type, lib.scope.lower(), len(lib), listener))
if not lib and not lib.has_listener:
LOGGER.warn("Imported library '%s' contains no keywords" % name)
def populate(self, path, datadir, include_suites):
LOGGER.info("Parsing test data directory '%s'" % path)
include_sub_suites = self._get_include_suites(path, include_suites)
initfile, children = self._get_children(path, include_sub_suites)
datadir.initfile = initfile
if initfile:
try:
FromFilePopulator(datadir).populate(initfile)
except DataError, err:
LOGGER.error(unicode(err))
def _import_resource(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
self._validate_not_importing_init_file(path)
if overwrite or path not in self._kw_store.resources:
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variable_table, overwrite)
self._kw_store.resources[path] = UserLibrary(resource.keyword_table.keywords, resource.source)
self._handle_imports(resource.setting_table.imports)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'" % (path, self.suite.longname))
def _import_library(self, name, positional, named, lib):
args = positional + ["%s=%s" % arg for arg in named]
key = (name, positional, named)
if key in self._library_cache:
LOGGER.info("Found test library '%s' with arguments %s from cache" % (name, seq2str2(args)))
return self._library_cache[key]
lib.create_handlers()
self._library_cache[key] = lib
self._log_imported_library(name, args, lib)
return lib
def set_from_file(self, path, args=None, overwrite=False):
LOGGER.info("Importing variable file '%s' with args %s" % (path, args))
var_file = self._import_variable_file(path)
try:
variables = self._get_variables_from_var_file(var_file, args)
self._set_from_file(variables, overwrite)
except:
amsg = "with arguments %s " % utils.seq2str2(args) if args else ""
raise DataError("Processing variable file '%s' %sfailed: %s" % (path, amsg, utils.get_error_message()))
return variables
def import_variables(self, path, args=None):
LOGGER.info("Importing variable file '%s' with args %s" % (path, args))
importer = Importer('variable file').import_class_or_module_by_path
var_file = importer(path, instantiate_with_args=())
try:
return self._get_variables(var_file, args)
except:
amsg = 'with arguments %s ' % seq2str2(args) if args else ''
raise DataError("Processing variable file '%s' %sfailed: %s"
% (path, amsg, get_error_message()))
def populate(self, path, datadir, include_suites=None,
include_extensions=None, recurse=True):
LOGGER.info("Parsing directory '%s'." % path)
include_suites = self._get_include_suites(path, include_suites)
init_file, children = self._get_children(path, include_extensions,
include_suites)
if init_file:
self._populate_init_file(datadir, init_file)
if recurse:
self._populate_children(datadir, children, include_extensions,
include_suites)
def _import_library(self, import_setting):
name = self._resolve_name(import_setting)
lib = IMPORTER.import_library(name, import_setting.args, import_setting.alias, self.variables)
if lib.name in self._kw_store.libraries:
LOGGER.info("Test library '%s' already imported by suite '%s'" % (lib.name, self.suite.longname))
return
self._kw_store.libraries[lib.name] = lib
lib.start_suite()
if self.test:
lib.start_test()
self._import_deprecated_standard_libs(lib.name)
def _import_variables(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
args = self._resolve_args(import_setting)
if overwrite or (path, args) not in self._imported_variable_files:
self._imported_variable_files.add((path, args))
self.variables.set_from_file(path, args, overwrite)
else:
msg = "Variable file '%s'" % path
if args:
msg += " with arguments %s" % utils.seq2str2(args)
LOGGER.info("%s already imported by suite '%s'" % (msg, self.suite.longname))
def set_from_file(self, path, args, overwrite=False):
LOGGER.info("Importing variable file '%s' with args %s" % (path, args))
args = args or []
try:
module = utils.simple_import(path)
variables = self._get_variables_from_module(module, args)
self._set_from_file(variables, overwrite, path)
except:
amsg = args and 'with arguments %s ' % utils.seq2str2(args) or ''
raise DataError("Processing variable file '%s' %sfailed: %s"
% (path, amsg, utils.get_error_message()))
return variables
def _import_resource(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
self._validate_not_importing_init_file(path)
if overwrite or path not in self._kw_store.resources:
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variables, overwrite)
user_library = UserLibrary(resource)
self._kw_store.resources[path] = user_library
self._handle_imports(resource.imports)
LOGGER.imported("Resource", user_library.name, importer=import_setting.source, source=path)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'" % (path, self._suite_name))
def _close_listener(self, listener):
method = (getattr(listener, 'close', None) or
getattr(listener, '_close', None))
try:
if method:
method()
except:
message, details = get_error_details()
name = getattr(listener, '__name__', None) or type_name(listener)
LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
% (method.__name__, name, message))
LOGGER.info("Details:\n%s" % details)
def _import_resource(self, import_setting, variables):
path = self._resolve_name(import_setting, variables)
if path not in self._imported_resource_files:
self._imported_resource_files.append(path)
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variable_table)
self._userlibs.append(UserLibrary(resource.keyword_table.keywords,
resource.source))
self._handle_imports(resource.setting_table.imports)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'"
% (path, self.suite.longname))
def _import_resource(self, import_setting, variables):
path = self._resolve_name(import_setting, variables)
if path not in self._imported_resource_files:
self._imported_resource_files.append(path)
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variable_table)
self._userlibs.append(
UserLibrary(resource.keyword_table.keywords, resource.source))
self._handle_imports(resource.setting_table.imports)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'" %
(path, self.suite.longname))
def _close_listener(self, listener):
method = (getattr(listener, 'close', None) or
getattr(listener, '_close', None))
try:
if method:
method()
except:
message, details = get_error_details()
name = getattr(listener, '__name__', None) or type_name(listener)
LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
% (method.__name__, name, message))
LOGGER.info("Details:\n%s" % details)
def _import_library(self, name, positional, named, lib):
args = positional + ['%s=%s' % arg for arg in sorted(named.items())]
key = (name, positional, named)
if key in self._library_cache:
LOGGER.info(
"Found test library '%s' with arguments %s from cache" %
(name, utils.seq2str2(args)))
return self._library_cache[key]
lib.create_handlers()
self._library_cache[key] = lib
self._log_imported_library(name, args, lib)
return lib
def _import_variables(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
args = self._resolve_args(import_setting)
if overwrite or (path, args) not in self._imported_variable_files:
self._imported_variable_files.add((path,args))
self.variables.set_from_file(path, args, overwrite)
else:
msg = "Variable file '%s'" % path
if args:
msg += " with arguments %s" % utils.seq2str2(args)
LOGGER.info("%s already imported by suite '%s'"
% (msg, self.suite.longname))
def set_from_file(self, path, args=None, overwrite=False):
LOGGER.info("Importing variable file '%s' with args %s" % (path, args))
args = args or []
module = self._importer.import_class_or_module_by_path(path)
try:
variables = self._get_variables_from_module(module, args)
self._set_from_file(variables, overwrite, path)
except:
amsg = 'with arguments %s ' % utils.seq2str2(args) if args else ''
raise DataError("Processing variable file '%s' %sfailed: %s"
% (path, amsg, utils.get_error_message()))
return variables
def set_from_file(self, path, args, overwrite=False):
LOGGER.info("Importing varible file '%s' with args %s" % (path, args))
args = args or []
try:
module = utils.simple_import(path)
variables = self._get_variables_from_module(module, args)
self._set_from_file(variables, overwrite, path)
except:
amsg = args and 'with arguments %s ' % utils.seq2str2(args) or ''
raise DataError("Processing variable file '%s' %sfailed: %s"
% (path, amsg, utils.get_error_message()))
return variables
def _import_resource(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
self._validate_not_importing_init_file(path)
if overwrite or path not in self._kw_store.resources:
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variable_table,
overwrite)
self._kw_store.resources[path] \
= UserLibrary(resource.keyword_table.keywords, resource.source)
self._handle_imports(resource.setting_table.imports)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'"
% (path, self.suite.longname))
def build_suite(source, datapath=None, parent_defaults=None,
process_curdir=True):
suite = TestSuite(name=format_name(source), source=source)
defaults = TestDefaults(parent_defaults)
if datapath:
ast = get_test_case_file_ast(datapath, process_curdir)
ErrorLogger(datapath).visit(ast)
SettingsBuilder(suite, defaults).visit(ast)
SuiteBuilder(suite, defaults).visit(ast)
if not suite.tests:
LOGGER.info("Data source '%s' has no tests or tasks." % datapath)
suite.rpa = _get_rpa_mode(ast)
return suite, defaults
def __init__(self, suite, variables, parent_variables, user_keywords,
imports):
LOGGER.info("Initializing namespace for test suite '%s'" % suite.longname)
self.suite = suite
self.test = None
self.uk_handlers = []
self.variables = _VariableScopes(variables, parent_variables)
self.library_search_order = []
self._imports = imports
self._user_keywords = UserLibrary(user_keywords)
self._testlibs = {}
self._imported_resource_files = ImportCache()
self._imported_variable_files = ImportCache()
def _import_library(self, import_setting, variables):
name = self._get_library_name(import_setting, variables)
lib = IMPORTER.import_library(name, import_setting.args,
import_setting.alias, variables)
if lib.name in self._testlibs:
LOGGER.info("Test library '%s' already imported by suite '%s'"
% (lib.name, self.suite.longname))
return
self._testlibs[lib.name] = lib
lib.start_suite()
if self.test:
lib.start_test()
self._import_deprecated_standard_libs(lib.name)
def build_resource(data, source):
resource = ResourceFile(source=source)
if data.data_sections:
ErrorLogger(source).visit(data)
if data.has_tests:
raise DataError("Resource file '%s' cannot contain tests or tasks." %
source)
ResourceBuilder(resource).visit(data)
LOGGER.info("Imported resource file '%s' (%d keywords)."
% (source, len(resource.keywords)))
else:
LOGGER.warn("Imported resource file '%s' is empty." % source)
return resource
def __init__(self, suite, variables, parent_variables, user_keywords,
imports):
LOGGER.info("Initializing namespace for test suite '%s'" %
suite.longname)
self.suite = suite
self.test = None
self.uk_handlers = []
self.variables = _VariableScopes(variables, parent_variables)
self.library_search_order = []
self._imports = imports
self._user_keywords = UserLibrary(user_keywords)
self._testlibs = {}
self._imported_resource_files = ImportCache()
self._imported_variable_files = ImportCache()
def _get_children(self, dirpath, incl_suites):
init_file = None
children = []
for name, path in self._list_dir(dirpath):
if self._is_init_file(name, path):
if not init_file:
init_file = path
else:
LOGGER.error("Ignoring second test suite init file '%s'." % path)
elif self._is_included(name, path, incl_suites):
children.append(path)
else:
LOGGER.info("Ignoring file or directory '%s'." % name)
return init_file, children
def _set_cli_vars(settings):
for path, args in settings['VariableFiles']:
try:
GLOBAL_VARIABLES.set_from_file(path, args)
except:
msg, details = utils.get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings['Variables']:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
GLOBAL_VARIABLES['${%s}' % name] = value
def _import_library(self, import_setting):
name = self._resolve_name(import_setting)
lib = IMPORTER.import_library(name, import_setting.args,
import_setting.alias, self.variables)
if lib.name in self._kw_store.libraries:
LOGGER.info("Test library '%s' already imported by suite '%s'" %
(lib.name, self.suite.longname))
return
self._kw_store.libraries[lib.name] = lib
lib.start_suite()
if self.test:
lib.start_test()
if name in STDLIB_TO_DEPRECATED_MAP:
self.import_library(STDLIB_TO_DEPRECATED_MAP[name])
def populate(self,
path,
datadir,
include_suites=None,
warn_on_skipped=False,
recurse=True):
LOGGER.info("Parsing test data directory '%s'" % path)
include_suites = self._get_include_suites(path, include_suites or [])
init_file, children = self._get_children(path, include_suites)
if init_file:
self._populate_init_file(datadir, init_file)
if recurse:
self._populate_children(datadir, children, include_suites,
warn_on_skipped)
def _list_dir(self, dir_path, incl_extensions, incl_suites):
# os.listdir returns Unicode entries when path is Unicode
names = os.listdir(unic(dir_path))
for name in sorted(names, key=lambda item: item.lower()):
name = unic(name) # needed to handle nfc/nfd normalization on OSX
path = os.path.join(dir_path, name)
base, ext = os.path.splitext(name)
ext = ext[1:].lower()
if self._is_init_file(path, base, ext, incl_extensions):
yield path, True
elif self._is_included(path, base, ext, incl_extensions,
incl_suites):
yield path, False
else:
LOGGER.info("Ignoring file or directory '%s'." % name)
def populate(self,
path,
datadir,
include_suites=None,
include_extensions=None,
recurse=True):
LOGGER.info("Parsing directory '%s'." % path)
include_suites = self._get_include_suites(path, include_suites)
init_file, children = self._get_children(path, include_extensions,
include_suites)
if init_file:
self._populate_init_file(datadir, init_file)
if recurse:
self._populate_children(datadir, children, include_extensions,
include_suites)
def main(self, datasources, **options):
settings = RobotSettings(options)
LOGGER.register_console_logger(**settings.console_logger_config)
LOGGER.info('Settings:\n%s' % unicode(settings))
suite = TestSuiteBuilder(settings['SuiteNames'],
settings['WarnOnSkipped'],
settings['RunEmptySuite']).build(*datasources)
suite.configure(**settings.suite_config)
result = suite.run(settings)
LOGGER.info("Tests execution ended. Statistics:\n%s" %
result.suite.stat_message)
if settings.log or settings.report or settings.xunit:
writer = ResultWriter(settings.output if settings.log else result)
writer.write_results(settings.get_rebot_settings())
return result.return_code
def _import_resource(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
self._validate_not_importing_init_file(path)
if overwrite or path not in self._kw_store.resources:
resource = IMPORTER.import_resource(path)
self.variables.set_from_variable_table(resource.variables, overwrite)
user_library = UserLibrary(resource)
self._kw_store.resources[path] = user_library
self._handle_imports(resource.imports)
LOGGER.imported("Resource", user_library.name,
importer=import_setting.source,
source=path)
else:
LOGGER.info("Resource file '%s' already imported by suite '%s'"
% (path, self._suite_name))
def _import_if_needed(self, path_or_variables, args=None):
if not is_string(path_or_variables):
return path_or_variables
LOGGER.info("Importing variable file '%s' with args %s" %
(path_or_variables, args))
if path_or_variables.lower().endswith('.yaml'):
importer = YamlImporter()
else:
importer = PythonImporter()
try:
return importer.import_variables(path_or_variables, args)
except:
args = 'with arguments %s ' % seq2str2(args) if args else ''
raise DataError("Processing variable file '%s' %sfailed: %s" %
(path_or_variables, args, get_error_message()))
def _set_cli_variables(self, settings):
for path, args in settings.variable_files:
try:
path = find_file(path, file_type='Variable file')
self.set_from_file(path, args)
except:
msg, details = get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings.variables:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
self['${%s}' % name] = value
def _import_variables(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
args = self._resolve_args(import_setting)
if overwrite or (path, args) not in self._imported_variable_files:
self._imported_variable_files.add((path, args))
self.variables.set_from_file(path, args, overwrite)
LOGGER.imported("Variables", os.path.basename(path),
args=list(args),
importer=import_setting.source,
source=path)
else:
msg = "Variable file '%s'" % path
if args:
msg += " with arguments %s" % seq2str2(args)
LOGGER.info("%s already imported by suite '%s'"
% (msg, self._suite_name))
def _set_cli_variables(self, settings):
for name, args in settings.variable_files:
try:
if name.lower().endswith(self._import_by_path_ends):
name = find_file(name, file_type='Variable file')
self.set_from_file(name, args)
except:
msg, details = get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings.variables:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
self['${%s}' % name] = value
def _build_suite(self, structure):
parent_defaults = self._stack[-1][-1] if self._stack else None
source = structure.source
defaults = TestDefaults(parent_defaults)
parser = self._get_parser(structure.extension)
try:
if structure.is_directory:
suite = parser.parse_init_file(structure.init_file or source, defaults)
else:
suite = parser.parse_suite_file(source, defaults)
if not suite.tests:
LOGGER.info("Data source '%s' has no tests or tasks." % source)
self._validate_execution_mode(suite)
except DataError as err:
raise DataError("Parsing '%s' failed: %s" % (source, err.message))
return suite, defaults
def _import_library(self, name, positional, named, lib):
key = (name, positional, named)
if self._libraries.has_key(key):
LOGGER.info(
"Found test library '%s' with arguments %s from cache" %
(name, utils.seq2str2(positional)))
return self._libraries[key]
lib.create_handlers()
self._libraries[key] = lib
libtype = lib.__class__.__name__.replace('Library', '').lower()[1:]
LOGGER.info("Imported library '%s' with arguments %s (version %s, "
"%s type, %s scope, %d keywords, source %s)" %
(name, utils.seq2str2(positional), lib.version, libtype,
lib.scope.lower(), len(lib), lib.source))
if len(lib) == 0:
LOGGER.warn("Imported library '%s' contains no keywords" % name)
return lib
def _import_variables(self, import_setting, overwrite=False):
path = self._resolve_name(import_setting)
args = self._resolve_args(import_setting)
if overwrite or (path, args) not in self._imported_variable_files:
self._imported_variable_files.add((path, args))
self.variables.set_from_file(path, args, overwrite)
LOGGER.imported("Variables",
os.path.basename(path),
args=list(args),
importer=import_setting.source,
source=path)
else:
msg = f"Variable file '{path}'"
if args:
msg += f" with arguments {seq2str2(args)}"
LOGGER.info(
f"{msg} already imported by suite '{self._suite_name}'.")
def _list_dir(self, dir_path, incl_suites):
try:
names = os.listdir(dir_path)
except:
raise DataError("Reading directory '%s' failed: %s"
% (dir_path, get_error_message()))
for name in sorted(names, key=lambda item: item.lower()):
name = safe_str(name) # Handles NFC normalization on OSX
path = os.path.join(dir_path, name)
base, ext = os.path.splitext(name)
ext = ext[1:].lower()
if self._is_init_file(path, base, ext):
yield path, True
elif self._is_included(path, base, ext, incl_suites):
yield path, False
else:
LOGGER.info("Ignoring file or directory '%s'." % path)
def process_output(path, read_level=-1, log_level=None):
"""Process one output file and return TestSuite and ExecutionErrors
'read_level' can be used to limit how many suite levels are read. This is
mainly useful when Robot has split outputs and only want to read index.
"""
if not os.path.isfile(path):
raise DataError("Output file '%s' does not exist." % path)
LOGGER.info("Processing output file '%s'." % path)
try:
root = utils.DomWrapper(path)
except:
err = utils.get_error_message()
raise DataError("Opening XML file '%s' failed: %s" % (path, err))
suite = _get_suite_node(root, path)
errors = _get_errors_node(root)
return TestSuite(suite, read_level,
log_level=log_level), ExecutionErrors(errors)
def _import_library(self, import_setting, notify=True):
name = self._resolve_name(import_setting)
lib = IMPORTER.import_library(name, import_setting.args,
import_setting.alias, self.variables)
if lib.name in self._kw_store.libraries:
LOGGER.info("Test library '%s' already imported by suite '%s'"
% (lib.name, self._suite_name))
return
if notify:
LOGGER.imported("Library", lib.name,
args=list(import_setting.args),
originalname=lib.orig_name,
importer=import_setting.source,
source=lib.source)
self._kw_store.libraries[lib.name] = lib
lib.start_suite()
if self._running_test:
lib.start_test()
def main(self, datasources, **options):
settings = RobotSettings(options)
LOGGER.register_console_logger(**settings.console_output_config)
LOGGER.info('Settings:\n%s' % unicode(settings))
suite = TestSuiteBuilder(settings['SuiteNames'],
settings['WarnOnSkipped']).build(*datasources)
suite.configure(**settings.suite_config)
if settings.pre_run_modifiers:
suite.visit(ModelModifier(settings.pre_run_modifiers,
settings.run_empty_suite, LOGGER))
with pyloggingconf.robot_handler_enabled(settings.log_level):
result = suite.run(settings)
LOGGER.info("Tests execution ended. Statistics:\n%s"
% result.suite.stat_message)
if settings.log or settings.report or settings.xunit:
writer = ResultWriter(settings.output if settings.log
else result)
writer.write_results(settings.get_rebot_settings())
return result.return_code
def _list_dir(self, dir_path, incl_suites):
# os.listdir returns Unicode entries when path is Unicode
dir_path = unic(dir_path)
try:
names = os.listdir(dir_path)
except:
raise DataError("Reading directory '%s' failed: %s" %
(dir_path, get_error_message()))
for name in sorted(names, key=lambda item: item.lower()):
name = unic(name) # needed to handle nfc/nfd normalization on OSX
path = os.path.join(dir_path, name)
base, ext = os.path.splitext(name)
ext = ext[1:].lower()
if self._is_init_file(path, base, ext):
yield path, True
elif self._is_included(path, base, ext, incl_suites):
yield path, False
else:
LOGGER.info("Ignoring file or directory '%s'." % path)
