def _verify_lib(self, lib, libname, keywords):
assert_equals(libname, lib.name)
for name, _ in keywords:
handler = lib.handlers[name]
exp = "%s.%s" % (libname, name)
assert_equals(utils.normalize(handler.longname),
utils.normalize(exp))
def _get_deprecated_setter(self, name):
normalized = normalize(name)
for setting in list(self._setters) + list(self._aliases):
if normalize(setting) == normalized:
self._report_deprecated_setting(name, setting)
return self._get_setter(setting)
return None
def _verify_lib(self, lib, libname, keywords):
assert_equals(libname, lib.name)
for name, _ in keywords:
handler = lib.get_handler(name)
exp = "%s.%s" % (libname, name)
assert_equals(utils.normalize(handler.longname),
utils.normalize(exp))
def check_suite_contains_tests(self, suite, *expected_names, **statuses):
actual_tests = [test for test in self.get_tests_from_suite(suite)]
tests_msg = """
Expected tests : %s
Actual tests : %s""" % (str(list(expected_names)), str(actual_tests))
expected_names = [utils.normalize(name) for name in expected_names]
statuses = dict((utils.normalize(k), v) for k, v in statuses.items())
if len(actual_tests) != len(expected_names):
raise AssertionError("Wrong number of tests." + tests_msg)
for test in actual_tests:
norm_name = utils.normalize(test.name)
if utils.MultiMatcher(expected_names).match(test.name):
print("Verifying test '%s'" % test.name)
status = statuses.get(norm_name)
if status and ':' in status:
status, message = status.split(':', 1)
else:
message = None
self.check_test_status(test, status, message)
expected_names.remove(norm_name)
else:
raise AssertionError(
"Test '%s' was not expected to be run.%s" %
(test.name, tests_msg))
assert not expected_names
def _get_deprecated_setter(self, name):
normalized = normalize(name)
for setting in list(self._setters) + list(self._aliases):
if normalize(setting) == normalized:
self._report_deprecated_setting(name, setting)
return self._get_setter(setting)
return None
def check_suite_contains_tests(self, suite, *expected_names, **statuses):
actual_tests = [test for test in self.get_tests_from_suite(suite)]
tests_msg = """
Expected tests : %s
Actual tests : %s""" % (
str(list(expected_names)),
str(actual_tests),
)
expected_names = [utils.normalize(name) for name in expected_names]
statuses = dict((utils.normalize(k), v) for k, v in statuses.items())
if len(actual_tests) != len(expected_names):
raise AssertionError("Wrong number of tests." + tests_msg)
for test in actual_tests:
norm_name = utils.normalize(test.name)
if utils.MultiMatcher(expected_names).match(test.name):
print "Verifying test '%s'" % test.name
status = statuses.get(norm_name)
if status and ":" in status:
status, message = status.split(":", 1)
else:
message = None
self.check_test_status(test, status, message)
expected_names.remove(norm_name)
else:
raise AssertionError("Test '%s' was not expected to be run.%s" % (test.name, tests_msg))
assert not expected_names
def test_normalize_with_ignore(self):
assert_equals(normalize('Foo_ bar', ignore=['_']), 'foobar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'f', 'o']), 'bar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'F', 'o']), 'bar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'f', 'o'],
caseless=False), 'Fbar')
assert_equals(normalize('Foo_\n bar\n', ignore=['\n'],
spaceless=False), 'foo_ bar')
def test_normalize_with_ignore(self):
assert_equals(normalize('Foo_ bar', ignore=['_']), 'foobar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'f', 'o']), 'bar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'F', 'o']), 'bar')
assert_equals(normalize('Foo_ bar', ignore=['_', 'f', 'o'],
caseless=False), 'Fbar')
assert_equals(normalize('Foo_\n bar\n', ignore=['\n'],
spaceless=False), 'foo_ bar')
def _resolve_deprecated_table(self, used_name):
normalized = normalize(used_name)
for name in (self._setting_table_names + self._variable_table_names +
self._testcase_table_names + self._keyword_table_names +
self._comment_table_names):
if normalize(name) == normalized:
self._report_deprecated_table(used_name, name)
return name
return None
def _resolve_deprecated_table(self, used_name):
normalized = normalize(used_name)
for name in (self._setting_table_names + self._variable_table_names +
self._testcase_table_names + self._keyword_table_names +
self._comment_table_names):
if normalize(name) == normalized:
self._report_deprecated_table(used_name, name)
return name
return None
def _add_to_dict(self, s_or_t, column_name):
name = s_or_t.longname.replace('_', ' ')
keys = self.suites_and_tests.keys()
found = False
for key in keys:
if utils.normalize(name, caseless=True, spaceless=True) == \
utils.normalize(key, caseless=True, spaceless=True):
found = True
foundkey = key
if not found:
self.suites_and_tests[name] = [(column_name, s_or_t)]
else:
self.suites_and_tests[foundkey].append((column_name, s_or_t))
def _convert(self, value, explicit_type=True):
try:
# This is compatible with the enum module in Python 3.4, its
# enum34 backport, and the older enum module. `self._enum[value]`
# wouldn't work with the old enum module.
return getattr(self._enum, value)
except AttributeError:
members = self._get_members(self._enum)
normalized_value = normalize(value, ignore='_')
for member in members:
if normalize(member, ignore='_') == normalized_value:
return getattr(self._enum, member)
raise ValueError("%s does not have member '%s'. Available: %s" %
(self.type_name, value, seq2str(members)))
def check_attribute(self, name, expected):
try:
actual = getattr(self, utils.normalize(name))
except AttributeError:
raise AssertionError("Attribute '%s' not set" % name)
if not utils.eq(actual, expected):
raise AssertionError("Attribute '%s' was '%s', expected '%s'" % (name, actual, expected))
def normalizer(value):
"""Normalize `value` based on normalizing options from metaclass.
"""
if isinstance(value, UserString):
value = value.data
return normalize(value, ignore=cls.ignore,
caseless=cls.caseless, spaceless=cls.spaceless)
def test_normalize_with_defaults(self):
for inp, exp in [('', ''), (' ', ''), (' \n\t\r', ''),
('foo', 'foo'), ('BAR', 'bar'), (' f o o ', 'foo'),
('_BAR', '_bar'), ('Fo OBar\r\n', 'foobar'),
('foo\tbar', 'foobar'),
('\n \n \n \n F o O \t\tBaR \r \r \r ', 'foobar')]:
assert_equals(normalize(inp), exp)
def _get_scope(self, libcode):
try:
scope = libcode.ROBOT_LIBRARY_SCOPE
scope = utils.normalize(scope, ignore=['_']).upper()
except (AttributeError, TypeError):
scope = 'TESTCASE'
return scope if scope in ['GLOBAL', 'TESTSUITE'] else 'TESTCASE'
def _get_scope(self, libcode):
try:
scope = libcode.ROBOT_LIBRARY_SCOPE
scope = utils.normalize(scope, ignore=['_']).upper()
except (AttributeError, TypeError):
scope = 'TESTCASE'
return scope if scope in ['GLOBAL','TESTSUITE'] else 'TESTCASE'
def check_suite_contains_tests(self, suite, *expected_names):
actual_tests = [test for test in self.get_tests_from_suite(suite)]
tests_msg = """
Expected tests : %s
Actual tests : %s""" % (str(list(expected_names)), str(actual_tests))
expected_names = [utils.normalize(name) for name in expected_names]
if len(actual_tests) != len(expected_names):
raise AssertionError("Wrong number of tests." + tests_msg)
for test in actual_tests:
if any(utils.matches(test.name, name) for name in expected_names):
print "Verifying test '%s'" % test.name
self.check_test_status(test)
expected_names.remove(utils.normalize(test.name))
else:
raise AssertionError("Test '%s' was not expected to be run.%s"
% (test.name, tests_msg))
assert not expected_names
def normalizer(value):
"""Normalize `value` based on normalizing options
given to :func:`normstringclass`.
"""
if isinstance(value, UserString):
value = value.data
return normalize(value, ignore=normalizer.ignore,
caseless=normalizer.caseless, spaceless=normalizer.spaceless)
def find(self, name):
if name[0] != '$':
raise ValueError
number = normalize(name)[2:-1]
try:
return self._get_int(number)
except ValueError:
return float(number)
def find(self, name):
number = normalize(name)[2:-1]
for converter in self._get_int, float:
try:
return converter(number)
except ValueError:
pass
return NOT_FOUND
def check_suite_contains_tests(self, suite, *expected_names):
actual_tests = [test for test in self.get_tests_from_suite(suite)]
tests_msg = """
Expected tests : %s
Actual tests : %s""" % (str(list(expected_names)), str(actual_tests))
expected_names = [utils.normalize(name) for name in expected_names]
if len(actual_tests) != len(expected_names):
raise AssertionError("Wrong number of tests." + tests_msg)
for test in actual_tests:
if any(utils.matches(test.name, name) for name in expected_names):
print "Verifying test '%s'" % test.name
self.check_test_status(test)
expected_names.remove(utils.normalize(test.name))
else:
raise AssertionError("Test '%s' was not expected to be run.%s"
% (test.name, tests_msg))
assert not expected_names
def find(self, name):
if name[0] != '$':
raise ValueError
number = normalize(name)[2:-1]
try:
return self._get_int(number)
except ValueError:
return float(number)
def check_attribute(self, name, expected):
try:
actual = getattr(self, utils.normalize(name))
except AttributeError:
raise AssertionError("Attribute '%s' not set" % name)
if not utils.eq(actual, expected):
raise AssertionError("Attribute '%s' was '%s', expected '%s'"
% (name, actual, expected))
def _get_attr(self, fields, name, upper=False):
name = 'ROBOT_LIBRARY_' + name
for field in fields:
if field.getSimpleName().toString() == name:
value = field.getConstantValue()
if upper:
value = normalize(value, ignore='_').upper()
return value
return ''
def _get_attr(self, fields, name, upper=False):
name = 'ROBOT_LIBRARY_' + name
for field in fields:
if field.getSimpleName().toString() == name:
value = field.getConstantValue()
if upper:
value = normalize(value, ignore='_').upper()
return value
return ''
def recommend_similar_keywords(self, name, message):
"""Return keyword names similar to `name`."""
candidates = self._get_candidates('.' in name)
finder = RecommendationFinder(
lambda name: normalize(candidates.get(name, name), ignore='_'))
return finder.find_and_format(name,
candidates,
message,
check_missing_argument_separator=True)
def normalizer(value):
"""Normalize `value` based on normalizing options from metaclass.
"""
if isinstance(value, UserString):
value = value.data
return normalize(value,
ignore=cls.ignore,
caseless=cls.caseless,
spaceless=cls.spaceless)
def _get_attr(self, doc, name, default='', upper=False):
name = 'ROBOT_LIBRARY_' + name
for field in doc.fields():
if field.name() == name and field.isPublic():
value = field.constantValue()
if upper:
value = utils.normalize(value, ignore='_').upper()
return value
return default
def _get_attr(self, doc, name, default='', upper=False):
name = 'ROBOT_LIBRARY_' + name
for field in doc.fields():
if field.name() == name and field.isPublic():
value = field.constantValue()
if upper:
value = utils.normalize(value, ignore='_').upper()
return value
return default
def _run_tests(self, context, errors):
executed_tests = []
for test in self.tests:
normname = utils.normalize(test.name)
if normname in executed_tests:
LOGGER.warn("Multiple test cases with name '%s' executed in "
"test suite '%s'"% (test.name, self.longname))
executed_tests.append(normname)
test.run(context, errors)
context.set_prev_test_variables(test)
def normalizer(value):
"""Normalize `value` based on normalizing options
given to :func:`normboolclass`.
- Any non-string values are just passed through.
"""
if not isinstance(value, string_types):
return value
return normalize(value, ignore=normalizer.ignore,
caseless=normalizer.caseless, spaceless=normalizer.spaceless)
def normalizer(value):
"""Normalize `value` based on normalizing options
given to :func:`normstringclass`.
"""
if isinstance(value, UserString):
value = value.data
return normalize(value,
ignore=normalizer.ignore,
caseless=normalizer.caseless,
spaceless=normalizer.spaceless)
def _run_tests(self, context, errors):
executed_tests = []
for test in self.tests:
normname = utils.normalize(test.name)
if normname in executed_tests:
LOGGER.warn("Multiple test cases with name '%s' executed in "
"test suite '%s'" % (test.name, self.longname))
executed_tests.append(normname)
test.run(context, errors)
context.set_prev_test_variables(test)
def _get_flavor_and_index(self, declaration):
for index, item in enumerate(declaration):
if item in self.flavors:
return item, index
if item in self.normalized_flavors:
correct = self.normalized_flavors[item]
self._report_deprecated_flavor_syntax(item, correct)
return correct, index
if normalize(item).startswith('in'):
return item.upper(), index
return 'IN', len(declaration)
def _get_flavor_and_index(self, declaration):
for index, item in enumerate(declaration):
if item in self.flavors:
return item, index
if item in self.normalized_flavors:
correct = self.normalized_flavors[item]
self._report_deprecated_flavor_syntax(item, correct)
return correct, index
if normalize(item).startswith('in'):
return item.upper(), index
return 'IN', len(declaration)
def _set_execution_mode(self, data):
rpa = normalize(data.testcase_table.header[0]) in ('task', 'tasks')
if self.rpa is None:
self.rpa = rpa
elif self.rpa is not rpa:
this, that = ('tasks', 'tests') if rpa else ('tests', 'tasks')
raise DataError("Conflicting execution modes. File '%s' has %s "
"but files parsed earlier have %s. Fix headers "
"or use '--rpa' or '--norpa' options to set the "
"execution mode explicitly." %
(data.source, this, that))
def _set_execution_mode(self, data):
rpa = normalize(data.testcase_table.header[0]) in ('task', 'tasks')
if self.rpa is None:
self.rpa = rpa
elif self.rpa is not rpa:
this, that = ('tasks', 'tests') if rpa else ('tests', 'tasks')
raise DataError("Conflicting execution modes. File '%s' has %s "
"but files parsed earlier have %s. Fix headers "
"or use '--rpa' or '--norpa' options to set the "
"execution mode explicitly."
% (data.source, this, that))
def convert_path(self, path_in, dir_out, format_in, format_out, root=None):
root = root if root is not None else Path.cwd()
# Override default docstring format
if path_in in self.config.get("override_docstring", {}):
self.logger.debug(f"Overriding docstring format for '{path_in}'")
format_in = self.config["override_docstring"][path_in]
# Override default output format
if path_in in self.config.get("override_format", {}):
self.logger.debug(f"Overriding output format for '{path_in}'")
format_out = self.config["override_format"][path_in]
converter = CONVERTERS[format_out]
path_rel = path_in.with_suffix(converter.EXTENSION).relative_to(root)
if self.config.get("collapse", False):
path_out = Path(dir_out) / Path("_".join(
part.lower() for part in path_rel.parts))
else:
path_out = Path(dir_out) / path_rel
path_out.parent.mkdir(parents=True, exist_ok=True)
self.logger.debug("Converting '%s' to '%s'", path_in, path_out)
libdoc = LibraryDocumentation(str(path_in),
doc_format=format_in.upper())
# Override name with user-given value
if self.config.get("title"):
libdoc.name = self.config["title"]
# Create module path for library, e.g. RPA.Excel.Files
else:
namespace = []
if self.config.get("namespace"):
namespace.append(self.config["namespace"])
if path_rel.parent != Path("."):
namespace.append(str(path_rel.parent).replace(os.sep, "."))
if namespace:
libdoc.name = "{namespace}.{name}".format(
namespace=".".join(namespace),
name=libdoc.name,
)
# Convert library scope to RPA format
if self.config.get("rpa", False):
scope = normalize(unic(libdoc.scope), ignore="_")
libdoc.scope = {
"testcase": "Task",
"testsuite": "Suite",
"global": "Global",
}.get(scope, "")
converter().convert(libdoc, path_out)
def test_normalize_with_defaults(self):
for inp, exp in [('', ''),
(' ', ''),
(' \n\t\r', ''),
('foo', 'foo'),
('BAR', 'bar'),
(' f o o ', 'foo'),
('_BAR', '_bar'),
('Fo OBar\r\n', 'foobar'),
('foo\tbar', 'foobar'),
('\n \n \n \n F o O \t\tBaR \r \r \r ', 'foobar')]:
assert_equals(normalize(inp), exp)
def normalizer(value):
"""Normalize `value` based on normalizing options
given to :func:`normboolclass`.
- Any non-string values are just passed through.
"""
if not isinstance(value, string_types):
return value
return normalize(value,
ignore=normalizer.ignore,
caseless=normalizer.caseless,
spaceless=normalizer.spaceless)
def repeat_keyword(self,times,name,*args):
times = utils.normalize(str(times))
if times.endswith('times'):
times = times[:-5]
elif times.endswith('x'):
times = times[:-1]
times = self._convert_to_integer(times)
if times <=0:
self.log("Keyword '%s repeat zero times" %name)
for i in xrange(times):
self.log("Repeating keyword,round %d/%d" %(i+1,times))
self.run_keyword(name,*args)
def test_normalize_with_defaults(self):
for inp, exp in [
("", ""),
(" ", ""),
(" \n\t\r", ""),
("foo", "foo"),
(" f o o ", "foo"),
("_BAR", "_bar"),
("Fo OBar\r\n", "foobar"),
("foo\tbar", "foobar"),
("\n \n \n \n F o O \t\tBaR \r \r \r ", "foobar"),
]:
assert_equals(exp, normalize(inp))
def _get_base(self,item,base):
if not isinstance(item,basestring):
return item,base
item = utils.normalize(item)
if item.startswith(('-','+')):
sign = item[0]
item =item[1:]
else:
sign = ''
base = {'0b':2,'0o':8,'0x': 16}
if base or not item.startswith(tuple(bases)):
return sign+item,base
return sign+item[2:],bases[item[:2]]
def convert_to_bool(self, value, *true_false, **options):
if true_false:
lists = NormalizedDict({'true': [], 'false': []})
# choose the first list to fill with items
# based on given TRUE or FALSE specifier:
try:
t_or_f_list = lists[true_false[0]]
except KeyError:
raise ValueError("Expected TRUE or FALSE, not: %s" %
repr(true_false[0]))
for item in true_false[1:]:
if item in lists: #==> is new TRUE or FALSE specifier
#==> switch to corresponding list
t_or_f_list = lists[item]
if t_or_f_list:
raise ValueError("Multiple %s lists specfied." %
normalize(item).upper())
else:
t_or_f_list.append(item)
for key, items in lists.items():
if not items:
raise ValueError("No %s list specified." % key.upper())
if RobotBool(options.get('normalized', True)):
boolcls = normboolclass(**lists)
else:
boolcls = boolclass(**lists)
else:
boolcls = options.get('boolclass') or options.get('booltype')
if not boolcls: # fallback to robot's default bool conversion
return BUILTIN.convert_to_boolean(value)
if isstring(boolcls):
try: # is a registered bool class name?
boolcls = BOOL_CLASSES[boolcls]
except KeyError:
if '.' not in boolcls:
raise ValueError(
"No such bool class registered: '%s'" % boolcls)
modname, clsname = boolcls.rsplit('.', 1)
try: # is an importable 'module.class' string?
boolcls = getattr(__import__(modname), clsname)
except (ImportError, AttributeError):
raise ValueError("Can't import bool class: '%s'" %
boolcls)
elif not isboolclass(boolcls):
raise TypeError("No bool class: %s" % repr(boolcls))
BUILTIN._log_types(value)
return boolcls(value)
def convert_to_bool(self, value, *true_false, **options):
if true_false:
lists = NormalizedDict({'true': [], 'false': []})
# choose the first list to fill with items
# based on given TRUE or FALSE specifier:
try:
t_or_f_list = lists[true_false[0]]
except KeyError:
raise ValueError("Expected TRUE or FALSE, not: %s"
% repr(true_false[0]))
for item in true_false[1:]:
if item in lists: #==> is new TRUE or FALSE specifier
#==> switch to corresponding list
t_or_f_list = lists[item]
if t_or_f_list:
raise ValueError("Multiple %s lists specfied."
% normalize(item).upper())
else:
t_or_f_list.append(item)
for key, items in lists.items():
if not items:
raise ValueError("No %s list specified." % key.upper())
if RobotBool(options.get('normalized', True)):
boolcls = normboolclass(**lists)
else:
boolcls = boolclass(**lists)
else:
boolcls = options.get('boolclass') or options.get('booltype')
if not boolcls: # fallback to robot's default bool conversion
return BUILTIN.convert_to_boolean(value)
if isstring(boolcls):
try: # is a registered bool class name?
boolcls = BOOL_CLASSES[boolcls]
except KeyError:
if '.' not in boolcls:
raise ValueError(
"No such bool class registered: '%s'" % boolcls)
modname, clsname = boolcls.rsplit('.', 1)
try: # is an importable 'module.class' string?
boolcls = getattr(__import__(modname), clsname)
except (ImportError, AttributeError):
raise ValueError(
"Can't import bool class: '%s'" % boolcls)
elif not isboolclass(boolcls):
raise TypeError("No bool class: %s" % repr(boolcls))
BUILTIN._log_types(value)
return boolcls(value)
def __init__(self, name):
#: Human readable identifier of the object these statistics
#: belong to. Either `All Tests` or `Critical Tests` for
#: :class:`~robot.model.totalstatistics.TotalStatistics`,
#: long name of the suite for
#: :class:`~robot.model.suitestatistics.SuiteStatistics`
#: or name of the tag for
#: :class:`~robot.model.tagstatistics.TagStatistics`
self.name = name
#: Number of passed tests.
self.passed = 0
#: Number of failed tests.
self.failed = 0
#: Number of milliseconds it took to execute.
self.elapsed = 0
self._norm_name = normalize(name, ignore='_')
def __init__(self, name):
#: Human readable identifier of the object these statistics
#: belong to. Either `All Tests` or `Critical Tests` for
#: :class:`~robot.model.totalstatistics.TotalStatistics`,
#: long name of the suite for
#: :class:`~robot.model.suitestatistics.SuiteStatistics`
#: or name of the tag for
#: :class:`~robot.model.tagstatistics.TagStatistics`
self.name = name
#: Number of passed tests.
self.passed = 0
#: Number of failed tests.
self.failed = 0
#: Number of milliseconds it took to execute.
self.elapsed = 0
self._norm_name = normalize(name, ignore='_')
def _get_attr(self, object, attr, default="", upper=False):
value = unic(getattr(object, attr, default))
if upper:
value = normalize(value, ignore="_").upper()
return value
def _get_attr(self, object, attr, default='', upper=False):
value = unic(getattr(object, attr, default))
if upper:
value = normalize(value, ignore='_').upper()
return value
def set_attribute(self, name, value):
setattr(self, utils.normalize(name), utils.normalize(value))
def recommend_similar_keywords(self, name):
"""Return keyword names similar to `name`."""
candidates = self._get_candidates('.' in name)
finder = RecommendationFinder(
lambda name: normalize(candidates.get(name, name), ignore='_'))
return finder.find(name, candidates)
def find(self, name):
number = normalize(name)[2:-1]
try:
return self._get_int(number)
except ValueError:
return float(number)
def delete(self, alias):
del(self._apps[normalize(alias)])
del(self._old_apps[normalize(alias)])
self._store()
def _get_scope(libcode):
if inspect.ismodule(libcode):
return 'global'
scope = getattr(libcode, 'ROBOT_LIBRARY_SCOPE', '')
return normalize(unic(scope), ignore='_')
def get_attribute(self, name):
return getattr(self, utils.normalize(name))
def check_attribute_not_set(self, name):
if hasattr(self, utils.normalize(name)):
raise AssertionError("Attribute '%s' should not be set" % name)
def _verify(self, string, expected, **config):
assert_equal(normalize(string, **config), expected)
def _verify_lib(self, lib, libname, keywords):
assert_equal(libname, lib.name)
for name, _ in keywords:
handler = lib.handlers[name]
exp = "%s.%s" % (libname, name)
assert_equal(normalize(handler.longname), normalize(exp))
def normalize(self, setting):
result = utils.normalize(setting)
return result[0:-1] if result and result[-1]==':' else result
