class _TestData(object):
_setting_table_names = 'Setting', 'Settings', 'Metadata'
_variable_table_names = 'Variable', 'Variables'
_testcase_table_names = 'Test Case', 'Test Cases'
_keyword_table_names = 'Keyword', 'Keywords', 'User Keyword', 'User Keywords'
_deprecated = NormalizedDict({
'Metadata': 'Settings',
'User Keyword': 'Keywords',
'User Keywords': 'Keywords'
})
def __init__(self, parent=None, source=None):
self.parent = parent
self.source = abspath(source) if source else None
self.children = []
self._tables = NormalizedDict(self._get_tables())
def _get_tables(self):
for names, table in [(self._setting_table_names, self.setting_table),
(self._variable_table_names, self.variable_table),
(self._testcase_table_names, self.testcase_table),
(self._keyword_table_names, self.keyword_table)]:
for name in names:
yield name, table
def start_table(self, header_row):
try:
name = header_row[0]
table = self._tables[name]
if name in self._deprecated:
self._report_deprecated(name)
except (KeyError, IndexError):
return None
if not self._table_is_allowed(table):
return None
table.set_header(header_row)
return table
def _report_deprecated(self, name):
self.report_invalid_syntax(
"Table name '%s' is deprecated. Please use '%s' instead." %
(name, self._deprecated[name]),
level='WARN')
@property
def name(self):
return self._format_name(self._get_basename()) if self.source else None
def _get_basename(self):
return os.path.splitext(os.path.basename(self.source))[0]
def _format_name(self, name):
name = self._strip_possible_prefix_from_name(name)
name = name.replace('_', ' ').strip()
return name.title() if name.islower() else name
def _strip_possible_prefix_from_name(self, name):
return name.split('__', 1)[-1]
@property
def keywords(self):
return self.keyword_table.keywords
@property
def imports(self):
return self.setting_table.imports
def report_invalid_syntax(self, message, level='ERROR'):
initfile = getattr(self, 'initfile', None)
path = os.path.join(self.source, initfile) if initfile else self.source
LOGGER.write("Error in file '%s': %s" % (path, message), level)
def save(self, **options):
"""Writes this datafile to disk.
:param options: Configuration for writing. These are passed to
:py:class:`~robot.writer.datafilewriter.WritingContext` as
keyword arguments.
See also :py:class:`robot.writer.datafilewriter.DataFileWriter`
"""
return DataFileWriter(**options).write(self)
def test_popping_items(self):
nd = NormalizedDict({'A': 1, 'b': 2})
assert_equals(nd.pop('A'), 1)
assert_equals(nd.pop('B'), 2)
assert_equals(nd.data, {})
assert_equals(nd.keys(), [])
def test_truth_value(self):
assert_false(NormalizedDict())
assert_true(NormalizedDict({'a': 1}))
def __init__(self):
self._stats = NormalizedDict()
self.column_names = []
def test_original_keys_are_preserved(self):
nd = NormalizedDict({'low': 1, 'UP': 2})
nd['up'] = nd['Spa Ce'] = 3
assert_equals(nd.keys(), ['low', 'Spa Ce', 'UP'])
assert_equals(nd.items(), [('low', 1), ('Spa Ce', 3), ('UP', 3)])
from robot.utils import NormalizedDict
from robot.libraries.BuiltIn import BuiltIn
BUILTIN = BuiltIn()
KEYWORDS = NormalizedDict({
'add_keyword': ('name', '*args'),
'remove_keyword': ('name', ),
'reload_self': (),
'original 1': ('arg', ),
'original 2': ('arg', ),
'original 3': ('arg', )
})
class Reloadable:
def get_keyword_names(self):
return list(KEYWORDS)
def get_keyword_arguments(self, name):
return KEYWORDS[name]
def get_keyword_documentation(self, name):
return 'Doc for %s with args %s' % (name, ', '.join(KEYWORDS[name]))
def run_keyword(self, name, args):
print("Running keyword '%s' with arguments %s." % (name, args))
assert name in KEYWORDS
if name == 'add_keyword':
KEYWORDS[args[0]] = args[1:]
elif name == 'remove_keyword':
def __init__(self, source, source_type):
self.source = source
self.source_type = source_type
self._normal = NormalizedDict(ignore='_')
self._embedded = []
def test_iter(self):
keys = list('123_aBcDeF')
nd = NormalizedDict((k, 1) for k in keys)
assert_equals(list(nd), keys)
assert_equals([key for key in nd], keys)
def test_keys_are_sorted(self):
nd = NormalizedDict((c, None) for c in 'aBcDeFg123XyZ___')
assert_equals(nd.keys(), list('123_aBcDeFgXyZ'))
def test_pop_with_default(self):
assert_equals(NormalizedDict().pop('nonex', 'default'), 'default')
def test_popitem_empty(self):
assert_raises(KeyError, NormalizedDict().popitem)
def test_contains(self):
nd = NormalizedDict({'Foo': 'bar'})
assert_true('Foo' in nd and 'foo' in nd and 'FOO' in nd)
def _escape_and_encode_targets(self, targets):
return NormalizedDict((html_escape(key), self._encode_uri_component(value))
for key, value in targets.items())
def __init__(self, parent=None, source=None):
self.parent = parent
self.source = abspath(source) if source else None
self.children = []
self._tables = NormalizedDict(self._get_tables())
def test_initial_values_as_name_value_pairs(self):
nd = NormalizedDict([('key', 'value'), ('F O\tO', 'bar')])
assert_equals(nd['key'], 'value')
assert_equals(nd['K EY'], 'value')
assert_equals(nd['foo'], 'bar')
def test_eq(self):
self._verify_eq(NormalizedDict(), NormalizedDict())
def test_ignore(self):
nd = NormalizedDict(ignore=['_'])
nd['foo_bar'] = 'value'
assert_equals(nd['foobar'], 'value')
assert_equals(nd['F oo\nB ___a r'], 'value')
def test_eq_with_normal_dict(self):
self._verify_eq(NormalizedDict(), {})
def __init__(self, variables):
self.store = NormalizedDict(ignore='_')
self._variables = variables
def test_eq_with_user_dict(self):
self._verify_eq(NormalizedDict(), UserDict())
def _deduplicate_normalized(self, tags):
normalized = NormalizedDict(((unic(t), 1) for t in tags), ignore='_')
for removed in '', 'NONE':
if removed in normalized:
normalized.pop(removed)
return tuple(normalized)
def test_eq_with_other_objects(self):
nd = NormalizedDict()
for other in ['string', 2, None, [], self.test_clear]:
assert_true(nd != other, other)
def test_has_key_and_contains(self):
nd = NormalizedDict({'Foo': 'bar'})
assert_true(nd.has_key('Foo') and nd.has_key(' f O o '))
assert_true('Foo' in nd and 'foo' in nd and 'FOO' in nd)
def test_clear(self):
nd = NormalizedDict({'a': 1, 'B': 2})
nd.clear()
assert_equals(nd._data, {})
assert_equals(nd._keys, {})
def test_deleting_items(self):
nd = NormalizedDict({'A': 1, 'b': 2})
del nd['A']
del nd['B']
assert_equals(nd.data, {})
assert_equals(nd.keys(), [])
def test_default_constructor(self):
nd = NormalizedDict()
nd['foo bar'] = 'value'
assert_equals(nd['foobar'], 'value')
assert_equals(nd['F oo\nBar'], 'value')
def test_len(self):
nd = NormalizedDict()
assert_equals(len(nd), 0)
nd['a'] = nd['b'] = nd['c'] = 1
assert_equals(len(nd), 3)
def test_initial_values_as_dict(self):
nd = NormalizedDict({'key': 'value', 'F O\tO': 'bar'})
assert_equals(nd['key'], 'value')
assert_equals(nd['K EY'], 'value')
assert_equals(nd['foo'], 'bar')
def test_str(self):
nd = NormalizedDict({'a': 1, 'B': 1})
assert_true(str(nd) in ("{'a': 1, 'B': 1}", "{'B': 1, 'a': 1}"))
def __init__(self):
self._apps = NormalizedDict()
self._old_apps = NormalizedDict()
for alias, url in self._get_aliases_and_urls_from_db():
self._old_apps[alias] = url
