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