/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 bzrlib/tests/test_registry.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

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