def test_registry_info(self): a_registry = registry.Registry() a_registry.register('one', 1, info='string info') # We should not have to import the module to return the info a_registry.register_lazy('two', 'nonexistent_module', 'member', info=2) # We should be able to handle a callable to get information a_registry.register('three', 3, info=['a', 'list']) obj = object() a_registry.register_lazy('four', 'nonexistent_module', 'member2', info=obj) a_registry.register('five', 5) self.assertEqual('string info', a_registry.get_info('one')) self.assertEqual(2, a_registry.get_info('two')) self.assertEqual(['a', 'list'], a_registry.get_info('three')) self.assertIs(obj, a_registry.get_info('four')) self.assertIs(None, a_registry.get_info('five')) self.assertRaises(KeyError, a_registry.get_info, None) self.assertRaises(KeyError, a_registry.get_info, 'six') a_registry.default_key = 'one' self.assertEqual('string info', a_registry.get_info(None)) self.assertRaises(KeyError, a_registry.get_info, 'six') self.assertEqual([('five', None), ('four', obj), ('one', 'string info'), ('three', ['a', 'list']), ('two', 2), ], sorted((key, a_registry.get_info(key)) for key in a_registry.keys()))
def test_normal_get_module(self): class AThing(object): """Something""" a_registry = registry.Registry() a_registry.register("obj", AThing()) self.assertEqual("breezy.tests.test_registry", a_registry._get_module("obj"))
def setUp(self): super(TestRegistryIter, self).setUp() # We create a registry with "official" objects and "hidden" # objects. The later represent the side effects that led to bug #277048 # and #430510 _registry = registry.Registry() def register_more(): _registry.register('hidden', None) # Avoid closing over self by binding local variable self.registry = _registry self.registry.register('passive', None) self.registry.register('active', register_more) self.registry.register('passive-too', None) class InvasiveGetter(registry._ObjectGetter): def get_obj(inner_self): # Surprise ! Getting a registered object (think lazy loaded # module) register yet another object ! _registry.register('more hidden', None) return inner_self._obj self.registry.register('hacky', None) # We peek under the covers because the alternative is to use lazy # registration and create a module that can reference our test registry # it's too much work for such a corner case -- vila 090916 self.registry._dict['hacky'] = InvasiveGetter(None)
def test_registry_help(self): a_registry = registry.Registry() a_registry.register('one', 1, help='help text for one') # We should not have to import the module to return the help # information a_registry.register_lazy('two', 'nonexistent_module', 'member', help='help text for two') # We should be able to handle a callable to get information help_calls = [] def generic_help(reg, key): help_calls.append(key) return 'generic help for %s' % (key,) a_registry.register('three', 3, help=generic_help) a_registry.register_lazy('four', 'nonexistent_module', 'member2', help=generic_help) a_registry.register('five', 5) def help_from_object(reg, key): obj = reg.get(key) return obj.help() class SimpleObj(object): def help(self): return 'this is my help' a_registry.register('six', SimpleObj(), help=help_from_object) self.assertEqual('help text for one', a_registry.get_help('one')) self.assertEqual('help text for two', a_registry.get_help('two')) self.assertEqual('generic help for three', a_registry.get_help('three')) self.assertEqual(['three'], help_calls) self.assertEqual('generic help for four', a_registry.get_help('four')) self.assertEqual(['three', 'four'], help_calls) self.assertEqual(None, a_registry.get_help('five')) self.assertEqual('this is my help', a_registry.get_help('six')) self.assertRaises(KeyError, a_registry.get_help, None) self.assertRaises(KeyError, a_registry.get_help, 'seven') a_registry.default_key = 'one' self.assertEqual('help text for one', a_registry.get_help(None)) self.assertRaises(KeyError, a_registry.get_help, 'seven') self.assertEqual([('five', None), ('four', 'generic help for four'), ('one', 'help text for one'), ('six', 'this is my help'), ('three', 'generic help for three'), ('two', 'help text for two'), ], sorted((key, a_registry.get_help(key)) for key in a_registry.keys())) # We don't know what order it was called in, but we should get # 2 more calls to three and four self.assertEqual(['four', 'four', 'three', 'three'], sorted(help_calls))
def test_get_prefix(self): my_registry = registry.Registry() http_object = object() sftp_object = object() my_registry.register('http:', http_object) my_registry.register('sftp:', sftp_object) found_object, suffix = my_registry.get_prefix('http://foo/bar') self.assertEqual('//foo/bar', suffix) self.assertIs(http_object, found_object) self.assertIsNot(sftp_object, found_object) found_object, suffix = my_registry.get_prefix('sftp://baz/qux') self.assertEqual('//baz/qux', suffix) self.assertIs(sftp_object, found_object)
def test_register_override(self): a_registry = registry.Registry() a_registry.register('one', 'one') self.assertRaises(KeyError, a_registry.register, 'one', 'two') self.assertRaises(KeyError, a_registry.register, 'one', 'two', override_existing=False) a_registry.register('one', 'two', override_existing=True) self.assertEqual('two', a_registry.get('one')) self.assertRaises(KeyError, a_registry.register_lazy, 'one', 'three', 'four') a_registry.register_lazy('one', 'module', 'member', override_existing=True)
def test_registry_alias(self): a_registry = registry.Registry() a_registry.register('one', 1, info='string info') a_registry.register_alias('two', 'one') a_registry.register_alias('three', 'one', info='own info') self.assertEqual(a_registry.get('one'), a_registry.get('two')) self.assertEqual(a_registry.get_help('one'), a_registry.get_help('two')) self.assertEqual(a_registry.get_info('one'), a_registry.get_info('two')) self.assertEqual('own info', a_registry.get_info('three')) self.assertEqual({'two': 'one', 'three': 'one'}, a_registry.aliases()) self.assertEqual( {'one': ['three', 'two']}, {k: sorted(v) for (k, v) in a_registry.alias_map().items()})
def test_registry_funcs(self): a_registry = registry.Registry() self.register_stuff(a_registry) self.assertTrue('one' in a_registry) a_registry.remove('one') self.assertFalse('one' in a_registry) self.assertRaises(KeyError, a_registry.get, 'one') a_registry.register('one', 'one') self.assertEqual(['five', 'four', 'one', 'two'], sorted(a_registry.keys())) self.assertEqual([('five', 5), ('four', 4), ('one', 'one'), ('two', 2)], sorted(a_registry.iteritems()))
def test_lazy_import_registry(self): plugin_name = self.create_simple_plugin() a_registry = registry.Registry() a_registry.register_lazy('obj', plugin_name, 'object1') a_registry.register_lazy('function', plugin_name, 'function') a_registry.register_lazy('klass', plugin_name, 'MyClass') a_registry.register_lazy('module', plugin_name, None) self.assertEqual(['function', 'klass', 'module', 'obj'], sorted(a_registry.keys())) # The plugin should not be loaded until we grab the first object self.assertFalse(plugin_name in sys.modules) # By default the plugin won't be in the search path self.assertRaises(ImportError, a_registry.get, 'obj') plugin_path = self.test_dir + '/tmp' sys.path.append(plugin_path) try: obj = a_registry.get('obj') self.assertEqual('foo', obj) self.assertTrue(plugin_name in sys.modules) # Now grab another object func = a_registry.get('function') self.assertEqual(plugin_name, func.__module__) self.assertEqual('function', func.__name__) self.assertEqual((1, [], '3'), func(1, [], '3')) # And finally a class klass = a_registry.get('klass') self.assertEqual(plugin_name, klass.__module__) self.assertEqual('MyClass', klass.__name__) inst = klass(1) self.assertIsInstance(inst, klass) self.assertEqual(1, inst.a) module = a_registry.get('module') self.assertIs(obj, module.object1) self.assertIs(func, module.function) self.assertIs(klass, module.MyClass) finally: sys.path.remove(plugin_path)
def test_registry(self): a_registry = registry.Registry() self.register_stuff(a_registry) self.assertTrue(a_registry.default_key is None) # test get() (self.default_key is None) self.assertRaises(KeyError, a_registry.get) self.assertRaises(KeyError, a_registry.get, None) self.assertEqual(2, a_registry.get('two')) self.assertRaises(KeyError, a_registry.get, 'three') # test _set_default_key a_registry.default_key = 'five' self.assertTrue(a_registry.default_key == 'five') self.assertEqual(5, a_registry.get()) self.assertEqual(5, a_registry.get(None)) # If they ask for a specific entry, they should get KeyError # not the default value. They can always pass None if they prefer self.assertRaises(KeyError, a_registry.get, 'six') self.assertRaises(KeyError, a_registry._set_default_key, 'six') # test keys() self.assertEqual(['five', 'four', 'one', 'two'], a_registry.keys())
def test_lazy_import_get_module(self): a_registry = registry.Registry() a_registry.register_lazy('obj', "breezy.tests.test_registry", 'object1') self.assertEqual("breezy.tests.test_registry", a_registry._get_module("obj"))
def _get_revno_str(self, revision_id): numbers = self._branch.revision_id_to_dotted_revno(revision_id) revno_str = '.'.join([str(num) for num in numbers]) return revno_str def generate(self, to_file): """Output the version information to the supplied file. :param to_file: The file to write the stream to. The output will already be encoded, so to_file should not try to change encodings. :return: None """ raise NotImplementedError(VersionInfoBuilder.generate) format_registry = registry.Registry() format_registry.register_lazy( 'rio', 'breezy.version_info_formats.format_rio', 'RioVersionInfoBuilder', 'Version info in RIO (simple text) format (default).') format_registry.default_key = 'rio' format_registry.register_lazy('python', 'breezy.version_info_formats.format_python', 'PythonVersionInfoBuilder', 'Version info in Python format.') format_registry.register_lazy('custom', 'breezy.version_info_formats.format_custom', 'CustomVersionInfoBuilder', 'Version info in Custom template-based format.')
def test_registry_alias_targetmissing(self): a_registry = registry.Registry() self.assertRaises(KeyError, a_registry.register_alias, 'one', 'two')
def test_registry_alias_exists(self): a_registry = registry.Registry() a_registry.register('one', 1, info='string info') a_registry.register('two', 2) self.assertRaises(KeyError, a_registry.register_alias, 'one', 'one')
def get_format_string(self): return 'bzr-hg sqlite cache v1\n' def open(self, transport): return SqliteIdmap(transport.local_abspath('idmap.db')) class TdbBzrHgCacheFormat(BzrHgCacheFormat): def get_format_string(self): return 'bzr-hg tdb cache v1\n' def open(self, transport): return TdbIdmap(transport.local_abspath('idmap.tdb')) formats = registry.Registry() formats.register(TdbBzrHgCacheFormat().get_format_string(), TdbBzrHgCacheFormat()) formats.register(SqliteBzrHgCacheFormat().get_format_string(), SqliteBzrHgCacheFormat()) try: import tdb except ImportError: formats.register('default', SqliteBzrHgCacheFormat()) else: formats.register('default', TdbBzrHgCacheFormat()) def get_remote_cache_transport(): return get_transport(get_cache_dir())
def test_lazy_import_registry_foo(self): a_registry = registry.Registry() a_registry.register_lazy('foo', 'breezy.branch', 'Branch') a_registry.register_lazy('bar', 'breezy.branch', 'Branch.hooks') self.assertEqual(branch.Branch, a_registry.get('foo')) self.assertEqual(branch.Branch.hooks, a_registry.get('bar'))
file ~/.bazaar/subversion.conf. If you have a custom repository, you can set the "branches" and "tags" variables. These variables can contain asterisks. Multiple locations can be separated by a semicolon. For example: [203ae883-c723-44c9-aabd-cb56e4f81c9a] branches = path/to/*/bla;path/to/trunk This would consider paths path/to/foo/bla, path/to/blie/bla and path/to/trunk branches, if they existed. The key used (203a...) is the UUID of the Subversion repository. The UUID for a repository can be found by running "svn info <url>" or "bzr info -v <url>". """ try: layout_registry = registry.Registry(__name__, "layout_registry") except TypeError: layout_registry = registry.Registry() layout_registry.register_lazy("root", __name__ + ".standard", "RootLayout") layout_registry.register_lazy("none", __name__ + ".layout.standard", "RootLayout") layout_registry.register_lazy("trunk", __name__ + ".layout.standard", "TrunkLayout0") for i in range(10): layout_registry.register_lazy("trunk%d" % i, __name__ + ".standard", "TrunkLayout%d" % i) layout_registry.register_lazy("trunk-variable", __name__ + ".standard", "TrunkLayoutVariable") layout_registry.register_lazy("itrunk1", __name__ + ".standard", "InverseTrunkLayout1")
file ~/.bazaar/subversion.conf. If you have a custom repository, you can set the "branches" and "tags" variables. These variables can contain asterisks. Multiple locations can be separated by a semicolon. For example: [203ae883-c723-44c9-aabd-cb56e4f81c9a] branches = path/to/*/bla;path/to/trunk This would consider paths path/to/foo/bla, path/to/blie/bla and path/to/trunk branches, if they existed. The key used (203a...) is the UUID of the Subversion repository. The UUID for a repository can be found by running "svn info <url>" or "bzr info -v <url>". """ try: layout_registry = registry.Registry("breezy.plugins.svn.layout", "layout_registry") except TypeError: layout_registry = registry.Registry() layout_registry.register_lazy("root", "breezy.plugins.svn.layout.standard", "RootLayout") layout_registry.register_lazy("none", "breezy.plugins.svn.layout.standard", "RootLayout") layout_registry.register_lazy("trunk", "breezy.plugins.svn.layout.standard", "TrunkLayout0") for i in range(10): layout_registry.register_lazy("trunk%d" % i, "breezy.plugins.svn.layout.standard", "TrunkLayout%d" % i) layout_registry.register_lazy("trunk-variable", "breezy.plugins.svn.layout.standard", "TrunkLayoutVariable")