def _create_handlers(self, libinst):
success, failure, details = self._get_reporting_methods()
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libinst):
err_pre = "Adding keyword '%s' to library '%s' failed: " % (
name, self.name)
try:
method = self._get_handler_method(self._libinst, name)
success("Got handler method '%s'" % (name))
except TypeError:
failure(err_pre + 'Not a method or function')
continue
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Getting handler method failed: ' + err_msg)
details('Details:\n%s' % err_details)
continue
try:
handlers[name] = self._create_handler(name, method)
success("Created keyword '%s'" % handlers[name].name)
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Creating keyword failed: ' + err_msg)
details('Details:\n%s' % err_details)
return handlers
def register_run_keyword(self, libname, keyword, args_to_process=None):
if args_to_process is None:
args_to_process = self._get_args_from_method(keyword)
keyword = keyword.__name__
if libname not in self._libs:
self._libs[libname] = utils.NormalizedDict(ignore=['_'])
self._libs[libname][keyword] = int(args_to_process)
def __init__(self, keywords):
self._targets = utils.NormalizedDict({
'introduction': 'introduction',
'library introduction': 'introduction',
'importing': 'importing',
'library importing': 'importing'
})
for kw in keywords:
self._targets[kw.name] = kw.name
def _get_setters(self):
return utils.NormalizedDict({'Documentation': self.doc.populate,
'Document': self.doc.populate,
'Template': self.template.populate,
'Setup': self.setup.populate,
'Precondition': self.setup.populate,
'Teardown': self.teardown.populate,
'Postcondition': self.teardown.populate,
'Tags': self.tags.populate,
'Timeout': self.timeout.populate})
def _copy_library(self, lib, newname):
libcopy = copy.copy(lib)
libcopy.name = newname
libcopy.init_scope_handling()
libcopy.handlers = utils.NormalizedDict(ignore=['_'])
for handler in lib.handlers.values():
handcopy = copy.copy(handler)
handcopy.library = libcopy
libcopy.handlers[handler.name] = handcopy
return libcopy
def _create_handlers(self, libcode):
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libcode):
method = self._try_to_get_handler_method(libcode, name)
if method:
handler = self._try_to_create_handler(name, method)
if handler:
handlers[name] = handler
self._log_success("Created keyword '%s'" % handler.name)
return handlers
def __init__(self, name, source=None, parent=None):
_TestAndSuiteHelper.__init__(self, name, parent)
self.source = source is not None and utils.normpath(source) or None
self.metadata = utils.NormalizedDict()
self.suites = []
self.tests = []
self.critical = _Critical()
self.critical_stats = Stat()
self.all_stats = Stat()
if parent:
parent.suites.append(self)
def __init__(self,
include=None,
exclude=None,
tag_stat_combine=None,
docs=None,
links=None):
self.stats = utils.NormalizedDict()
self._include = include or []
self._exclude = exclude or []
self._patterns_and_names = self._get_patterns_and_names(
tag_stat_combine)
self._taginfo = TagStatInfo(docs or [], links or [])
def __init__(self, user_keywords, path=None):
self.name = self._get_name_for_resource_file(path)
self.handlers = utils.NormalizedDict(ignore=['_'])
self.embedded_arg_handlers = []
for kw in user_keywords:
try:
handler = EmbeddedArgsTemplate(kw, self.name)
except DataError, err:
LOGGER.error("Creating user keyword '%s' failed: %s"
% (kw.name, unicode(err)))
continue
except TypeError:
handler = UserKeywordHandler(kw, self.name)
def __init__(self, name, source=None, parent=None):
_TestAndSuiteHelper.__init__(self, parent)
self._name = name
self.source = utils.abspath(source) if source else None
self._id = None
self.metadata = utils.NormalizedDict()
self.suites = []
self.tests = []
self.critical = _Critical()
self.critical_stats = Stat()
self.all_stats = Stat()
if parent:
parent.suites.append(self)
def _get_tables(self):
if not self._tables:
self._tables = utils.NormalizedDict({'Setting': self.setting_table,
'Settings': self.setting_table,
'Metadata': self.setting_table,
'Variable': self.variable_table,
'Variables': self.variable_table,
'Keyword': self.keyword_table,
'Keywords': self.keyword_table,
'User Keyword': self.keyword_table,
'User Keywords': self.keyword_table,
'Test Case': self.testcase_table,
'Test Cases': self.testcase_table})
return self._tables
def _create_handlers(self, libinst):
#if self.name == 'RemoteB': pdb.set_trace()
success, failure, details = self._get_reporting_methods()
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libinst):
err_pre = "Adding keyword '%s' to library '%s' failed: " % (
name, self.name)
try:
method = self._get_handler_method(libinst, name)
success("Got handler method '%s'" % (name))
except TypeError, err:
failure(err_pre + utils.unic(err))
continue
except:
def _get_targets(self, keywords, introduction, robot_format):
targets = utils.NormalizedDict({
'introduction': 'Introduction',
'library introduction': 'Introduction',
'importing': 'Importing',
'library importing': 'Importing',
'shortcuts': 'Shortcuts',
'keywords': 'Keywords'
})
for kw in keywords:
targets[kw.name] = kw.name
if robot_format:
for header in self._yield_header_targets(introduction):
targets[header] = header
return targets
def __init__(self, user_keywords, path=None):
self.name = self._get_name_for_resource_file(path)
self.handlers = utils.NormalizedDict(ignore=['_'])
self.embedded_arg_handlers = []
for user_keyword in user_keywords:
try:
handler = EmbeddedArgsTemplate(user_keyword, self.name)
except TypeError:
handler = UserKeywordHandler(user_keyword, self.name)
else:
self.embedded_arg_handlers.append(handler)
if handler.name in self.handlers:
err = "Keyword '%s' defined multiple times" % handler.name
handler = UserErrorHandler(handler.name, err)
self.handlers[handler.name] = handler
def __init__(self, user_keywords, path=None):
self.name = self._get_name_for_resource_file(path)
self.handlers = utils.NormalizedDict(ignore=['_'])
self.embedded_arg_handlers = []
for kw in user_keywords:
try:
handler = self._create_handler(kw)
except DataError as err:
LOGGER.error("Creating user keyword '%s' failed: %s" %
(kw.name, unicode(err)))
continue
if handler.name in self.handlers:
error = "Keyword '%s' defined multiple times." % handler.name
handler = UserErrorHandler(handler.name, error)
self.handlers[handler.name] = handler
def _get_setters(self):
return utils.NormalizedDict({'Documentation': self.doc.populate,
'Document': self.doc.populate,
'Suite Setup': self.suite_setup.populate,
'Suite Precondition': self.suite_setup.populate,
'Suite Teardown': self.suite_teardown.populate,
'Suite Postcondition': self.suite_teardown.populate,
'Test Setup': self.test_setup.populate,
'Test Precondition': self.test_setup.populate,
'Test Teardown': self.test_teardown.populate,
'Test Postcondition': self.test_teardown.populate,
'Force Tags': self.force_tags.populate,
'Library': self._get_adder(self.add_library),
'Resource': self._get_adder(self.add_resource),
'Variables': self._get_adder(self.add_variables),
'Metadata': self._get_adder(self.add_metadata)})
def _get_setters(self):
return utils.NormalizedDict({'Documentation': self.doc.populate,
'Document': self.doc.populate,
'Library': self._get_adder(self.add_library),
'Resource': self._get_adder(self.add_resource),
'Variables': self._get_adder(self.add_variables)})
def __init__(self, parent=None, source=None):
self.parent = parent
self.source = utils.abspath(source) if source else None
self.children = []
self._tables = utils.NormalizedDict(self._get_tables())
def _get_metadata(self, metadata):
meta = utils.NormalizedDict()
for item in metadata:
meta[item.name] = item.value
return meta
def _get_setters(self):
return utils.NormalizedDict({'Documentation': self.doc.populate,
'Document': self.doc.populate,
'Arguments': self.args.populate,
'Return': self.return_.populate,
'Timeout': self.timeout.populate})
