~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2006 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Tests for the Registry classes"""

import os

import sys

from bzrlib import (

    errors,

    registry,

    osutils,

    )

from bzrlib.tests import TestCase, TestCaseInTempDir

class TestRegistry(TestCase):

    def register_stuff(self, a_registry):

        a_registry.register('one', 1)

        a_registry.register('two', 2)

        a_registry.register('four', 4)

        a_registry.register('five', 5)

    def test_registry(self):

        a_registry = registry.Registry()

        self.register_stuff(a_registry)

        self.failUnless(a_registry.default_key is None)

        # test get() (self.default_key == 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.failUnless(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_registry_funcs(self):

        a_registry = registry.Registry()

        self.register_stuff(a_registry)

        self.failUnless('one' in a_registry)

        a_registry.remove('one')

        self.failIf('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_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_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_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()))

class TestRegistryWithDirs(TestCaseInTempDir):

    """Registry tests that require temporary dirs"""

    def create_plugin_file(self, contents):

        """Create a file to be used as a plugin.

        This is created in a temporary directory, so that we

        are sure that it doesn't start in the plugin path.

        """

        os.mkdir('tmp')

        plugin_name = 'bzr_plugin_a_%s' % (osutils.rand_chars(4),)

        open('tmp/'+plugin_name+'.py', 'wb').write(contents)

        return plugin_name

    def create_simple_plugin(self):

        return self.create_plugin_file(

            'object1 = "foo"\n'

            '\n\n'

            'def function(a,b,c):\n'

            '    return a,b,c\n'

            '\n\n'

            'class MyClass(object):\n'

            '    def __init__(self, a):\n'

            '      self.a = a\n'

            '\n\n'

        )

    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.failIf(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 = os.getcwd() + '/tmp'

        sys.path.append(plugin_path)

        try:

            obj = a_registry.get('obj')

            self.assertEqual('foo', obj)

            self.failUnless(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)