/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_registry.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_registry.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2008-2012, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
import os
20
20
import sys
21
21
 
22
 
from bzrlib import (
23
 
    errors,
 
22
from breezy import (
 
23
    branch,
24
24
    osutils,
25
25
    registry,
26
26
    tests,
27
27
    )
28
28
 
29
29
 
 
30
 
30
31
class TestRegistry(tests.TestCase):
31
32
 
32
33
    def register_stuff(self, a_registry):
39
40
        a_registry = registry.Registry()
40
41
        self.register_stuff(a_registry)
41
42
 
42
 
        self.failUnless(a_registry.default_key is None)
 
43
        self.assertTrue(a_registry.default_key is None)
43
44
 
44
45
        # test get() (self.default_key is None)
45
46
        self.assertRaises(KeyError, a_registry.get)
49
50
 
50
51
        # test _set_default_key
51
52
        a_registry.default_key = 'five'
52
 
        self.failUnless(a_registry.default_key == 'five')
 
53
        self.assertTrue(a_registry.default_key == 'five')
53
54
        self.assertEqual(5, a_registry.get())
54
55
        self.assertEqual(5, a_registry.get(None))
55
56
        # If they ask for a specific entry, they should get KeyError
64
65
        a_registry = registry.Registry()
65
66
        self.register_stuff(a_registry)
66
67
 
67
 
        self.failUnless('one' in a_registry)
 
68
        self.assertTrue('one' in a_registry)
68
69
        a_registry.remove('one')
69
 
        self.failIf('one' in a_registry)
 
70
        self.assertFalse('one' in a_registry)
70
71
        self.assertRaises(KeyError, a_registry.get, 'one')
71
72
 
72
73
        a_registry.register('one', 'one')
82
83
        a_registry.register('one', 'one')
83
84
        self.assertRaises(KeyError, a_registry.register, 'one', 'two')
84
85
        self.assertRaises(KeyError, a_registry.register, 'one', 'two',
85
 
                                    override_existing=False)
 
86
                          override_existing=False)
86
87
 
87
88
        a_registry.register('one', 'two', override_existing=True)
88
89
        self.assertEqual('two', a_registry.get('one'))
103
104
 
104
105
        # We should be able to handle a callable to get information
105
106
        help_calls = []
 
107
 
106
108
        def generic_help(reg, key):
107
109
            help_calls.append(key)
108
110
            return 'generic help for %s' % (key,)
144
146
                          ('six', 'this is my help'),
145
147
                          ('three', 'generic help for three'),
146
148
                          ('two', 'help text for two'),
147
 
                         ], sorted((key, a_registry.get_help(key))
 
149
                          ], sorted((key, a_registry.get_help(key))
148
150
                                    for key in a_registry.keys()))
149
151
 
150
152
        # We don't know what order it was called in, but we should get
184
186
                          ('one', 'string info'),
185
187
                          ('three', ['a', 'list']),
186
188
                          ('two', 2),
187
 
                         ], sorted((key, a_registry.get_info(key))
 
189
                          ], sorted((key, a_registry.get_info(key))
188
190
                                    for key in a_registry.keys()))
189
191
 
190
192
    def test_get_prefix(self):
201
203
        self.assertEqual('//baz/qux', suffix)
202
204
        self.assertIs(sftp_object, found_object)
203
205
 
 
206
    def test_registry_alias(self):
 
207
        a_registry = registry.Registry()
 
208
        a_registry.register('one', 1, info='string info')
 
209
        a_registry.register_alias('two', 'one')
 
210
        a_registry.register_alias('three', 'one', info='own info')
 
211
        self.assertEqual(a_registry.get('one'), a_registry.get('two'))
 
212
        self.assertEqual(a_registry.get_help('one'),
 
213
                         a_registry.get_help('two'))
 
214
        self.assertEqual(a_registry.get_info('one'),
 
215
                         a_registry.get_info('two'))
 
216
        self.assertEqual('own info', a_registry.get_info('three'))
 
217
        self.assertEqual({'two': 'one', 'three': 'one'}, a_registry.aliases())
 
218
        self.assertEqual(
 
219
            {'one': ['three', 'two']},
 
220
            {k: sorted(v) for (k, v) in a_registry.alias_map().items()})
 
221
 
 
222
    def test_registry_alias_exists(self):
 
223
        a_registry = registry.Registry()
 
224
        a_registry.register('one', 1, info='string info')
 
225
        a_registry.register('two', 2)
 
226
        self.assertRaises(KeyError, a_registry.register_alias, 'one', 'one')
 
227
 
 
228
    def test_registry_alias_targetmissing(self):
 
229
        a_registry = registry.Registry()
 
230
        self.assertRaises(KeyError, a_registry.register_alias, 'one', 'two')
 
231
 
204
232
 
205
233
class TestRegistryIter(tests.TestCase):
206
234
    """Test registry iteration behaviors.
215
243
        # We create a registry with "official" objects and "hidden"
216
244
        # objects. The later represent the side effects that led to bug #277048
217
245
        # and #430510
218
 
        self.registry =  registry.Registry()
 
246
        _registry = registry.Registry()
219
247
 
220
248
        def register_more():
221
 
            self.registry.register('hidden', None)
 
249
            _registry.register('hidden', None)
222
250
 
 
251
        # Avoid closing over self by binding local variable
 
252
        self.registry = _registry
223
253
        self.registry.register('passive', None)
224
254
        self.registry.register('active', register_more)
225
255
        self.registry.register('passive-too', None)
229
259
            def get_obj(inner_self):
230
260
                # Surprise ! Getting a registered object (think lazy loaded
231
261
                # module) register yet another object !
232
 
                self.registry.register('more hidden', None)
 
262
                _registry.register('more hidden', None)
233
263
                return inner_self._obj
234
264
 
235
265
        self.registry.register('hacky', None)
270
300
        """
271
301
        os.mkdir('tmp')
272
302
        plugin_name = 'bzr_plugin_a_%s' % (osutils.rand_chars(4),)
273
 
        open('tmp/'+plugin_name+'.py', 'wb').write(contents)
 
303
        with open('tmp/' + plugin_name + '.py', 'wb') as f:
 
304
            f.write(contents)
274
305
        return plugin_name
275
306
 
276
307
    def create_simple_plugin(self):
277
308
        return self.create_plugin_file(
278
 
            'object1 = "foo"\n'
279
 
            '\n\n'
280
 
            'def function(a,b,c):\n'
281
 
            '    return a,b,c\n'
282
 
            '\n\n'
283
 
            'class MyClass(object):\n'
284
 
            '    def __init__(self, a):\n'
285
 
            '      self.a = a\n'
286
 
            '\n\n'
 
309
            b'object1 = "foo"\n'
 
310
            b'\n\n'
 
311
            b'def function(a,b,c):\n'
 
312
            b'    return a,b,c\n'
 
313
            b'\n\n'
 
314
            b'class MyClass(object):\n'
 
315
            b'    def __init__(self, a):\n'
 
316
            b'      self.a = a\n'
 
317
            b'\n\n'
287
318
        )
288
319
 
 
320
    def test_lazy_import_registry_foo(self):
 
321
        a_registry = registry.Registry()
 
322
        a_registry.register_lazy('foo', 'breezy.branch', 'Branch')
 
323
        a_registry.register_lazy('bar', 'breezy.branch', 'Branch.hooks')
 
324
        self.assertEqual(branch.Branch, a_registry.get('foo'))
 
325
        self.assertEqual(branch.Branch.hooks, a_registry.get('bar'))
 
326
 
289
327
    def test_lazy_import_registry(self):
290
328
        plugin_name = self.create_simple_plugin()
291
329
        a_registry = registry.Registry()
297
335
        self.assertEqual(['function', 'klass', 'module', 'obj'],
298
336
                         sorted(a_registry.keys()))
299
337
        # The plugin should not be loaded until we grab the first object
300
 
        self.failIf(plugin_name in sys.modules)
 
338
        self.assertFalse(plugin_name in sys.modules)
301
339
 
302
340
        # By default the plugin won't be in the search path
303
341
        self.assertRaises(ImportError, a_registry.get, 'obj')
304
342
 
305
 
        plugin_path = os.getcwd() + '/tmp'
 
343
        plugin_path = self.test_dir + '/tmp'
306
344
        sys.path.append(plugin_path)
307
345
        try:
308
346
            obj = a_registry.get('obj')
309
347
            self.assertEqual('foo', obj)
310
 
            self.failUnless(plugin_name in sys.modules)
 
348
            self.assertTrue(plugin_name in sys.modules)
311
349
 
312
350
            # Now grab another object
313
351
            func = a_registry.get('function')
331
369
        finally:
332
370
            sys.path.remove(plugin_path)
333
371
 
 
372
    def test_lazy_import_get_module(self):
 
373
        a_registry = registry.Registry()
 
374
        a_registry.register_lazy('obj', "breezy.tests.test_registry",
 
375
                                 'object1')
 
376
        self.assertEqual("breezy.tests.test_registry",
 
377
                         a_registry._get_module("obj"))
 
378
 
 
379
    def test_normal_get_module(self):
 
380
        class AThing(object):
 
381
            """Something"""
 
382
        a_registry = registry.Registry()
 
383
        a_registry.register("obj", AThing())
 
384
        self.assertEqual("breezy.tests.test_registry",
 
385
                         a_registry._get_module("obj"))