/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: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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