← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_plugins.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-24 14:12:53 UTC
  • mto: This revision was merged to the branch mainline in revision 2095.
  • Revision ID: john@arbash-meinel.com-20061024141253-783fba812b197b70
(John Arbash Meinel) Update version information for 0.13 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
1
 
# Copyright (C) 2005, 2007 Canonical Ltd
 
1
# Copyright (C) 2005 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
22
22
 
23
23
import os
24
24
from StringIO import StringIO
25
 
import sys
26
 
import zipfile
27
25
 
28
 
from bzrlib import plugin, tests
29
26
import bzrlib.plugin
30
27
import bzrlib.plugins
31
28
import bzrlib.commands
32
29
import bzrlib.help
33
 
from bzrlib.tests import TestCase, TestCaseInTempDir
 
30
from bzrlib.tests import TestCaseInTempDir
34
31
from bzrlib.osutils import pathjoin, abspath
35
32
 
 
33
class PluginTest(TestCaseInTempDir):
 
34
    """Create an external plugin and test loading."""
 
35
#    def test_plugin_loading(self):
 
36
#        orig_help = self.run_bzr_captured('bzr help commands')[0]
 
37
#        os.mkdir('plugin_test')
 
38
#        f = open(pathjoin('plugin_test', 'myplug.py'), 'wt')
 
39
#        f.write(PLUGIN_TEXT)
 
40
#        f.close()
 
41
#        newhelp = self.run_bzr_captured('bzr help commands')[0]
 
42
#        assert newhelp.startswith('You have been overridden\n')
 
43
#        # We added a line, but the rest should work
 
44
#        assert newhelp[25:] == help
 
45
#
 
46
#        assert backtick('bzr commit -m test') == "I'm sorry dave, you can't do that\n"
 
47
#
 
48
#        shutil.rmtree('plugin_test')
 
49
#
 
50
 
 
51
#         os.environ['BZRPLUGINPATH'] = abspath('plugin_test')
 
52
#         help = backtick('bzr help commands')
 
53
#         assert help.find('myplug') != -1
 
54
#         assert help.find('Just a simple test plugin.') != -1
 
55
 
 
56
 
 
57
#         assert backtick('bzr myplug') == 'Hello from my plugin\n'
 
58
#         assert backtick('bzr mplg') == 'Hello from my plugin\n'
 
59
 
 
60
#         f = open(pathjoin('plugin_test', 'override.py'), 'wb')
 
61
#         f.write("""import bzrlib, bzrlib.commands
 
62
#     class cmd_commit(bzrlib.commands.cmd_commit):
 
63
#         '''Commit changes into a new revision.'''
 
64
#         def run(self, *args, **kwargs):
 
65
#             print "I'm sorry dave, you can't do that"
 
66
 
 
67
#     class cmd_help(bzrlib.commands.cmd_help):
 
68
#         '''Show help on a command or other topic.'''
 
69
#         def run(self, *args, **kwargs):
 
70
#             print "You have been overridden"
 
71
#             bzrlib.commands.cmd_help.run(self, *args, **kwargs)
 
72
 
 
73
#         """
36
74
 
37
75
PLUGIN_TEXT = """\
38
76
import bzrlib.commands
45
83
 
46
84
# TODO: Write a test for plugin decoration of commands.
47
85
 
48
 
class TestLoadingPlugins(TestCaseInTempDir):
 
86
class TestOneNamedPluginOnly(TestCaseInTempDir):
49
87
 
50
88
    activeattributes = {}
51
89
 
52
90
    def test_plugins_with_the_same_name_are_not_loaded(self):
53
 
        # This test tests that having two plugins in different directories does
54
 
        # not result in both being loaded when they have the same name.  get a
55
 
        # file name we can use which is also a valid attribute for accessing in
56
 
        # activeattributes. - we cannot give import parameters.
 
91
        # This test tests that having two plugins in different
 
92
        # directories does not result in both being loaded.
 
93
        # get a file name we can use which is also a valid attribute
 
94
        # for accessing in activeattributes. - we cannot give import parameters.
57
95
        tempattribute = "0"
58
96
        self.failIf(tempattribute in self.activeattributes)
59
97
        # set a place for the plugins to record their loading, and at the same
60
98
        # time validate that the location the plugins should record to is
61
99
        # valid and correct.
62
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
100
        bzrlib.tests.test_plugins.TestOneNamedPluginOnly.activeattributes \
63
101
            [tempattribute] = []
64
102
        self.failUnless(tempattribute in self.activeattributes)
65
103
        # create two plugin directories
67
105
        os.mkdir('second')
68
106
        # write a plugin that will record when its loaded in the 
69
107
        # tempattribute list.
70
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
71
 
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
108
        template = ("from bzrlib.tests.test_plugins import TestOneNamedPluginOnly\n"
 
109
                    "TestOneNamedPluginOnly.activeattributes[%r].append('%s')\n")
72
110
        print >> file(os.path.join('first', 'plugin.py'), 'w'), template % (tempattribute, 'first')
73
111
        print >> file(os.path.join('second', 'plugin.py'), 'w'), template % (tempattribute, 'second')
74
112
        try:
75
 
            bzrlib.plugin.load_from_path(['first', 'second'])
76
 
            self.assertEqual(['first'], self.activeattributes[tempattribute])
77
 
        finally:
78
 
            # remove the plugin 'plugin'
79
 
            del self.activeattributes[tempattribute]
80
 
            if getattr(bzrlib.plugins, 'plugin', None):
81
 
                del bzrlib.plugins.plugin
82
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
83
 
 
84
 
    def test_plugins_from_different_dirs_can_demand_load(self):
85
 
        # This test tests that having two plugins in different
86
 
        # directories with different names allows them both to be loaded, when
87
 
        # we do a direct import statement.
88
 
        # Determine a file name we can use which is also a valid attribute
89
 
        # for accessing in activeattributes. - we cannot give import parameters.
90
 
        tempattribute = "different-dirs"
91
 
        self.failIf(tempattribute in self.activeattributes)
92
 
        # set a place for the plugins to record their loading, and at the same
93
 
        # time validate that the location the plugins should record to is
94
 
        # valid and correct.
95
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
96
 
            [tempattribute] = []
97
 
        self.failUnless(tempattribute in self.activeattributes)
98
 
        # create two plugin directories
99
 
        os.mkdir('first')
100
 
        os.mkdir('second')
101
 
        # write plugins that will record when they are loaded in the 
102
 
        # tempattribute list.
103
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
104
 
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
105
 
        print >> file(os.path.join('first', 'pluginone.py'), 'w'), template % (tempattribute, 'first')
106
 
        print >> file(os.path.join('second', 'plugintwo.py'), 'w'), template % (tempattribute, 'second')
107
 
        oldpath = bzrlib.plugins.__path__
108
 
        try:
109
 
            bzrlib.plugins.__path__ = ['first', 'second']
110
 
            exec "import bzrlib.plugins.pluginone"
111
 
            self.assertEqual(['first'], self.activeattributes[tempattribute])
112
 
            exec "import bzrlib.plugins.plugintwo"
113
 
            self.assertEqual(['first', 'second'],
114
 
                self.activeattributes[tempattribute])
 
113
            bzrlib.plugin.load_from_dirs(['first', 'second'])
 
114
            self.assertEqual(['first'], self.activeattributes[tempattribute])
115
115
        finally:
116
116
            # remove the plugin 'plugin'
117
117
            del self.activeattributes[tempattribute]
129
129
        # write a plugin that _cannot_ fail to load.
130
130
        print >> file('plugin.py', 'w'), ""
131
131
        try:
132
 
            bzrlib.plugin.load_from_path(['.'])
 
132
            bzrlib.plugin.load_from_dirs(['.'])
133
133
            self.failUnless('plugin' in bzrlib.plugin.all_plugins())
134
134
            self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
135
135
            self.assertEqual(bzrlib.plugin.all_plugins()['plugin'],
136
136
                             bzrlib.plugins.plugin)
137
137
        finally:
138
138
            # remove the plugin 'plugin'
139
 
            if 'bzrlib.plugins.plugin' in sys.modules:
140
 
                del sys.modules['bzrlib.plugins.plugin']
141
139
            if getattr(bzrlib.plugins, 'plugin', None):
142
140
                del bzrlib.plugins.plugin
143
141
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
148
146
    def split_help_commands(self):
149
147
        help = {}
150
148
        current = None
151
 
        for line in self.run_bzr('help commands')[0].splitlines():
 
149
        for line in self.capture('help commands').splitlines():
152
150
            if not line.startswith(' '):
153
151
                current = line.split()[0]
154
152
            help[current] = help.get(current, '') + line
161
159
        for cmd_name in bzrlib.commands.builtin_command_names():
162
160
            if cmd_name in bzrlib.commands.plugin_command_names():
163
161
                continue
 
162
            help = StringIO()
164
163
            try:
165
 
                help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
 
164
                bzrlib.help.help_on_command(cmd_name, help)
166
165
            except NotImplementedError:
167
166
                # some commands have no help
168
167
                pass
169
168
            else:
170
 
                self.assertNotContainsRe(help, 'From plugin "[^"]*"')
 
169
                help.seek(0)
 
170
                self.assertNotContainsRe(help.read(), 'From plugin "[^"]*"')
171
171
 
172
 
            if cmd_name in help_commands.keys():
 
172
            if help in help_commands.keys():
173
173
                # some commands are hidden
174
174
                help = help_commands[cmd_name]
175
175
                self.assertNotContainsRe(help, 'From plugin "[^"]*"')
183
183
 
184
184
        try:
185
185
            # Check its help
186
 
            bzrlib.plugin.load_from_path(['plugin_test'])
 
186
            bzrlib.plugin.load_from_dirs(['plugin_test'])
187
187
            bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
188
 
            help = self.run_bzr('help myplug')[0]
 
188
            help = self.capture('help myplug')
189
189
            self.assertContainsRe(help, 'From plugin "myplug"')
190
190
            help = self.split_help_commands()['myplug']
191
191
            self.assertContainsRe(help, '\[myplug\]')
192
192
        finally:
193
 
            # unregister command
194
 
            if bzrlib.commands.plugin_cmds.get('myplug', None):
195
 
                del bzrlib.commands.plugin_cmds['myplug']
196
 
            # remove the plugin 'myplug'
197
 
            if getattr(bzrlib.plugins, 'myplug', None):
198
 
                delattr(bzrlib.plugins, 'myplug')
199
 
 
200
 
 
201
 
class TestPluginFromZip(TestCaseInTempDir):
202
 
 
203
 
    def make_zipped_plugin(self, zip_name, filename):
204
 
        z = zipfile.ZipFile(zip_name, 'w')
205
 
        z.writestr(filename, PLUGIN_TEXT)
206
 
        z.close()
207
 
 
208
 
    def check_plugin_load(self, zip_name, plugin_name):
209
 
        self.assertFalse(plugin_name in dir(bzrlib.plugins),
210
 
                         'Plugin already loaded')
211
 
        old_path = bzrlib.plugins.__path__
212
 
        try:
213
 
            # this is normally done by load_plugins -> set_plugins_path
214
 
            bzrlib.plugins.__path__ = [zip_name]
215
 
            bzrlib.plugin.load_from_zip(zip_name)
216
 
            self.assertTrue(plugin_name in dir(bzrlib.plugins),
217
 
                            'Plugin is not loaded')
218
 
        finally:
219
 
            # unregister plugin
220
 
            if getattr(bzrlib.plugins, plugin_name, None):
221
 
                delattr(bzrlib.plugins, plugin_name)
222
 
                del sys.modules['bzrlib.plugins.' + plugin_name]
223
 
            bzrlib.plugins.__path__ = old_path
224
 
 
225
 
    def test_load_module(self):
226
 
        self.make_zipped_plugin('./test.zip', 'ziplug.py')
227
 
        self.check_plugin_load('./test.zip', 'ziplug')
228
 
 
229
 
    def test_load_package(self):
230
 
        self.make_zipped_plugin('./test.zip', 'ziplug/__init__.py')
231
 
        self.check_plugin_load('./test.zip', 'ziplug')
232
 
 
233
 
 
234
 
class TestSetPluginsPath(TestCase):
235
 
    
236
 
    def test_set_plugins_path(self):
237
 
        """set_plugins_path should set the module __path__ correctly."""
238
 
        old_path = bzrlib.plugins.__path__
239
 
        try:
240
 
            bzrlib.plugins.__path__ = []
241
 
            expected_path = bzrlib.plugin.set_plugins_path()
242
 
            self.assertEqual(expected_path, bzrlib.plugins.__path__)
243
 
        finally:
244
 
            bzrlib.plugins.__path__ = old_path
245
 
 
246
 
 
247
 
class TestHelpIndex(tests.TestCase):
248
 
    """Tests for the PluginsHelpIndex class."""
249
 
 
250
 
    def test_default_constructable(self):
251
 
        index = plugin.PluginsHelpIndex()
252
 
 
253
 
    def test_get_topics_None(self):
254
 
        """Searching for None returns an empty list."""
255
 
        index = plugin.PluginsHelpIndex()
256
 
        self.assertEqual([], index.get_topics(None))
257
 
 
258
 
    def test_get_topics_for_plugin(self):
259
 
        """Searching for plugin name gets its docstring."""
260
 
        index = plugin.PluginsHelpIndex()
261
 
        # make a new plugin here for this test, even if we're run with
262
 
        # --no-plugins
263
 
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
264
 
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
265
 
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
266
 
        try:
267
 
            topics = index.get_topics('demo_module')
268
 
            self.assertEqual(1, len(topics))
269
 
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
270
 
            self.assertEqual(demo_module, topics[0].module)
271
 
        finally:
272
 
            del sys.modules['bzrlib.plugins.demo_module']
273
 
 
274
 
    def test_get_topics_no_topic(self):
275
 
        """Searching for something that is not a plugin returns []."""
276
 
        # test this by using a name that cannot be a plugin - its not
277
 
        # a valid python identifier.
278
 
        index = plugin.PluginsHelpIndex()
279
 
        self.assertEqual([], index.get_topics('nothing by this name'))
280
 
 
281
 
    def test_prefix(self):
282
 
        """PluginsHelpIndex has a prefix of 'plugins/'."""
283
 
        index = plugin.PluginsHelpIndex()
284
 
        self.assertEqual('plugins/', index.prefix)
285
 
 
286
 
    def test_get_plugin_topic_with_prefix(self):
287
 
        """Searching for plugins/demo_module returns help."""
288
 
        index = plugin.PluginsHelpIndex()
289
 
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
290
 
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
291
 
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
292
 
        try:
293
 
            topics = index.get_topics('plugins/demo_module')
294
 
            self.assertEqual(1, len(topics))
295
 
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
296
 
            self.assertEqual(demo_module, topics[0].module)
297
 
        finally:
298
 
            del sys.modules['bzrlib.plugins.demo_module']
299
 
 
300
 
 
301
 
class FakeModule(object):
302
 
    """A fake module to test with."""
303
 
 
304
 
    def __init__(self, doc, name):
305
 
        self.__doc__ = doc
306
 
        self.__name__ = name
307
 
 
308
 
 
309
 
class TestModuleHelpTopic(tests.TestCase):
310
 
    """Tests for the ModuleHelpTopic class."""
311
 
 
312
 
    def test_contruct(self):
313
 
        """Construction takes the module to document."""
314
 
        mod = FakeModule('foo', 'foo')
315
 
        topic = plugin.ModuleHelpTopic(mod)
316
 
        self.assertEqual(mod, topic.module)
317
 
 
318
 
    def test_get_help_text_None(self):
319
 
        """A ModuleHelpTopic returns the docstring for get_help_text."""
320
 
        mod = FakeModule(None, 'demo')
321
 
        topic = plugin.ModuleHelpTopic(mod)
322
 
        self.assertEqual("Plugin 'demo' has no docstring.\n",
323
 
            topic.get_help_text())
324
 
 
325
 
    def test_get_help_text_no_carriage_return(self):
326
 
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
327
 
        mod = FakeModule('one line of help', 'demo')
328
 
        topic = plugin.ModuleHelpTopic(mod)
329
 
        self.assertEqual("one line of help\n",
330
 
            topic.get_help_text())
331
 
 
332
 
    def test_get_help_text_carriage_return(self):
333
 
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
334
 
        mod = FakeModule('two lines of help\nand more\n', 'demo')
335
 
        topic = plugin.ModuleHelpTopic(mod)
336
 
        self.assertEqual("two lines of help\nand more\n",
337
 
            topic.get_help_text())
338
 
 
339
 
    def test_get_help_text_with_additional_see_also(self):
340
 
        mod = FakeModule('two lines of help\nand more', 'demo')
341
 
        topic = plugin.ModuleHelpTopic(mod)
342
 
        self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
343
 
            topic.get_help_text(['foo', 'bar']))
344
 
 
345
 
    def test_get_help_topic(self):
346
 
        """The help topic for a plugin is its module name."""
347
 
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
348
 
        topic = plugin.ModuleHelpTopic(mod)
349
 
        self.assertEqual('demo', topic.get_help_topic())
350
 
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
351
 
        topic = plugin.ModuleHelpTopic(mod)
352
 
        self.assertEqual('foo_bar', topic.get_help_topic())
 
193
            # remove the plugin 'plugin'
 
194
            if getattr(bzrlib.plugins, 'plugin', None):
 
195
                del bzrlib.plugins.plugin