← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_registry.py

(vila) Forbid more operations on ReadonlyTransportDecorator (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_registry.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006, 2008-2011 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the Registry classes"""
18
18
 
20
20
import sys
21
21
 
22
22
from bzrlib import (
23
 
    errors,
 
23
    branch,
 
24
    osutils,
24
25
    registry,
25
 
    osutils,
 
26
    tests,
26
27
    )
27
 
from bzrlib.tests import TestCase, TestCaseInTempDir
28
 
 
29
 
 
30
 
class TestRegistry(TestCase):
 
28
 
 
29
 
 
30
class TestRegistry(tests.TestCase):
31
31
 
32
32
    def register_stuff(self, a_registry):
33
33
        a_registry.register('one', 1)
39
39
        a_registry = registry.Registry()
40
40
        self.register_stuff(a_registry)
41
41
 
42
 
        self.failUnless(a_registry.default_key is None)
 
42
        self.assertTrue(a_registry.default_key is None)
43
43
 
44
 
        # test get() (self.default_key == None)
 
44
        # test get() (self.default_key is None)
45
45
        self.assertRaises(KeyError, a_registry.get)
46
46
        self.assertRaises(KeyError, a_registry.get, None)
47
47
        self.assertEqual(2, a_registry.get('two'))
49
49
 
50
50
        # test _set_default_key
51
51
        a_registry.default_key = 'five'
52
 
        self.failUnless(a_registry.default_key == 'five')
 
52
        self.assertTrue(a_registry.default_key == 'five')
53
53
        self.assertEqual(5, a_registry.get())
54
54
        self.assertEqual(5, a_registry.get(None))
55
55
        # If they ask for a specific entry, they should get KeyError
64
64
        a_registry = registry.Registry()
65
65
        self.register_stuff(a_registry)
66
66
 
67
 
        self.failUnless('one' in a_registry)
 
67
        self.assertTrue('one' in a_registry)
68
68
        a_registry.remove('one')
69
 
        self.failIf('one' in a_registry)
 
69
        self.assertFalse('one' in a_registry)
70
70
        self.assertRaises(KeyError, a_registry.get, 'one')
71
71
 
72
72
        a_registry.register('one', 'one')
187
187
                         ], sorted((key, a_registry.get_info(key))
188
188
                                    for key in a_registry.keys()))
189
189
 
190
 
 
191
 
class TestRegistryWithDirs(TestCaseInTempDir):
 
190
    def test_get_prefix(self):
 
191
        my_registry = registry.Registry()
 
192
        http_object = object()
 
193
        sftp_object = object()
 
194
        my_registry.register('http:', http_object)
 
195
        my_registry.register('sftp:', sftp_object)
 
196
        found_object, suffix = my_registry.get_prefix('http://foo/bar')
 
197
        self.assertEqual('//foo/bar', suffix)
 
198
        self.assertIs(http_object, found_object)
 
199
        self.assertIsNot(sftp_object, found_object)
 
200
        found_object, suffix = my_registry.get_prefix('sftp://baz/qux')
 
201
        self.assertEqual('//baz/qux', suffix)
 
202
        self.assertIs(sftp_object, found_object)
 
203
 
 
204
 
 
205
class TestRegistryIter(tests.TestCase):
 
206
    """Test registry iteration behaviors.
 
207
 
 
208
    There are dark corner cases here when the registered objects trigger
 
209
    addition in the iterated registry.
 
210
    """
 
211
 
 
212
    def setUp(self):
 
213
        super(TestRegistryIter, self).setUp()
 
214
 
 
215
        # We create a registry with "official" objects and "hidden"
 
216
        # objects. The later represent the side effects that led to bug #277048
 
217
        # and #430510
 
218
        _registry = registry.Registry()
 
219
 
 
220
        def register_more():
 
221
           _registry.register('hidden', None)
 
222
 
 
223
        # Avoid closing over self by binding local variable
 
224
        self.registry = _registry
 
225
        self.registry.register('passive', None)
 
226
        self.registry.register('active', register_more)
 
227
        self.registry.register('passive-too', None)
 
228
 
 
229
        class InvasiveGetter(registry._ObjectGetter):
 
230
 
 
231
            def get_obj(inner_self):
 
232
                # Surprise ! Getting a registered object (think lazy loaded
 
233
                # module) register yet another object !
 
234
                _registry.register('more hidden', None)
 
235
                return inner_self._obj
 
236
 
 
237
        self.registry.register('hacky', None)
 
238
        # We peek under the covers because the alternative is to use lazy
 
239
        # registration and create a module that can reference our test registry
 
240
        # it's too much work for such a corner case -- vila 090916
 
241
        self.registry._dict['hacky'] = InvasiveGetter(None)
 
242
 
 
243
    def _iter_them(self, iter_func_name):
 
244
        iter_func = getattr(self.registry, iter_func_name, None)
 
245
        self.assertIsNot(None, iter_func)
 
246
        count = 0
 
247
        for name, func in iter_func():
 
248
            count += 1
 
249
            self.assertFalse(name in ('hidden', 'more hidden'))
 
250
            if func is not None:
 
251
                # Using an object register another one as a side effect
 
252
                func()
 
253
        self.assertEqual(4, count)
 
254
 
 
255
    def test_iteritems(self):
 
256
        # the dict is modified during the iteration
 
257
        self.assertRaises(RuntimeError, self._iter_them, 'iteritems')
 
258
 
 
259
    def test_items(self):
 
260
        # we should be able to iterate even if one item modify the dict
 
261
        self._iter_them('items')
 
262
 
 
263
 
 
264
class TestRegistryWithDirs(tests.TestCaseInTempDir):
192
265
    """Registry tests that require temporary dirs"""
193
266
 
194
267
    def create_plugin_file(self, contents):
199
272
        """
200
273
        os.mkdir('tmp')
201
274
        plugin_name = 'bzr_plugin_a_%s' % (osutils.rand_chars(4),)
202
 
        open('tmp/'+plugin_name+'.py', 'wb').write(contents)
 
275
        with open('tmp/'+plugin_name+'.py', 'wb') as f: f.write(contents)
203
276
        return plugin_name
204
277
 
205
278
    def create_simple_plugin(self):
215
288
            '\n\n'
216
289
        )
217
290
 
 
291
    def test_lazy_import_registry_foo(self):
 
292
        a_registry = registry.Registry()
 
293
        a_registry.register_lazy('foo', 'bzrlib.branch', 'Branch')
 
294
        a_registry.register_lazy('bar', 'bzrlib.branch', 'Branch.hooks')
 
295
        self.assertEqual(branch.Branch, a_registry.get('foo'))
 
296
        self.assertEqual(branch.Branch.hooks, a_registry.get('bar'))
 
297
 
218
298
    def test_lazy_import_registry(self):
219
299
        plugin_name = self.create_simple_plugin()
220
300
        a_registry = registry.Registry()
226
306
        self.assertEqual(['function', 'klass', 'module', 'obj'],
227
307
                         sorted(a_registry.keys()))
228
308
        # The plugin should not be loaded until we grab the first object
229
 
        self.failIf(plugin_name in sys.modules)
 
309
        self.assertFalse(plugin_name in sys.modules)
230
310
 
231
311
        # By default the plugin won't be in the search path
232
312
        self.assertRaises(ImportError, a_registry.get, 'obj')
236
316
        try:
237
317
            obj = a_registry.get('obj')
238
318
            self.assertEqual('foo', obj)
239
 
            self.failUnless(plugin_name in sys.modules)
 
319
            self.assertTrue(plugin_name in sys.modules)
240
320
 
241
321
            # Now grab another object
242
322
            func = a_registry.get('function')
260
340
        finally:
261
341
            sys.path.remove(plugin_path)
262
342
 
 
343
    def test_lazy_import_get_module(self):
 
344
        a_registry = registry.Registry()
 
345
        a_registry.register_lazy('obj', "bzrlib.tests.test_registry",
 
346
            'object1')
 
347
        self.assertEquals("bzrlib.tests.test_registry",
 
348
            a_registry._get_module("obj"))
 
349
 
 
350
    def test_normal_get_module(self):
 
351
        class AThing(object):
 
352
            """Something"""
 
353
        a_registry = registry.Registry()
 
354
        a_registry.register("obj", AThing())
 
355
        self.assertEquals("bzrlib.tests.test_registry",
 
356
            a_registry._get_module("obj"))