/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_plugins.py

  • Committer: Aaron Bentley
  • Date: 2008-10-28 10:31:32 UTC
  • mto: (0.14.36 prepare-shelf)
  • mto: This revision was merged to the branch mainline in revision 3820.
  • Revision ID: aaron@aaronbentley.com-20081028103132-syota6mcye41kvqh
Update to use Tree.readlines, if possible.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
 
1
# Copyright (C) 2005, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""Tests for plugins"""
 
18
 
 
19
# XXX: There are no plugin tests at the moment because the plugin module
 
20
# affects the global state of the process.  See bzrlib/plugins.py for more
 
21
# comments.
 
22
 
 
23
import logging
 
24
import os
 
25
from StringIO import StringIO
 
26
import sys
 
27
import zipfile
 
28
 
 
29
from bzrlib import plugin, tests
 
30
import bzrlib.plugin
 
31
import bzrlib.plugins
 
32
import bzrlib.commands
 
33
import bzrlib.help
 
34
from bzrlib.symbol_versioning import one_three
 
35
from bzrlib.tests import (
 
36
    TestCase,
 
37
    TestCaseInTempDir,
 
38
    TestUtil,
 
39
    )
 
40
from bzrlib.osutils import pathjoin, abspath, normpath
 
41
 
 
42
 
 
43
PLUGIN_TEXT = """\
 
44
import bzrlib.commands
 
45
class cmd_myplug(bzrlib.commands.Command):
 
46
    '''Just a simple test plugin.'''
 
47
    aliases = ['mplg']
 
48
    def run(self):
 
49
        print 'Hello from my plugin'
 
50
"""
 
51
 
 
52
# TODO: Write a test for plugin decoration of commands.
 
53
 
 
54
class TestLoadingPlugins(TestCaseInTempDir):
 
55
 
 
56
    activeattributes = {}
 
57
 
 
58
    def test_plugins_with_the_same_name_are_not_loaded(self):
 
59
        # This test tests that having two plugins in different directories does
 
60
        # not result in both being loaded when they have the same name.  get a
 
61
        # file name we can use which is also a valid attribute for accessing in
 
62
        # activeattributes. - we cannot give import parameters.
 
63
        tempattribute = "0"
 
64
        self.failIf(tempattribute in self.activeattributes)
 
65
        # set a place for the plugins to record their loading, and at the same
 
66
        # time validate that the location the plugins should record to is
 
67
        # valid and correct.
 
68
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
69
            [tempattribute] = []
 
70
        self.failUnless(tempattribute in self.activeattributes)
 
71
        # create two plugin directories
 
72
        os.mkdir('first')
 
73
        os.mkdir('second')
 
74
        # write a plugin that will record when its loaded in the 
 
75
        # tempattribute list.
 
76
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
77
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
78
 
 
79
        outfile = open(os.path.join('first', 'plugin.py'), 'w')
 
80
        try:
 
81
            outfile.write(template % (tempattribute, 'first'))
 
82
            outfile.write('\n')
 
83
        finally:
 
84
            outfile.close()
 
85
 
 
86
        outfile = open(os.path.join('second', 'plugin.py'), 'w')
 
87
        try:
 
88
            outfile.write(template % (tempattribute, 'second'))
 
89
            outfile.write('\n')
 
90
        finally:
 
91
            outfile.close()
 
92
 
 
93
        try:
 
94
            bzrlib.plugin.load_from_path(['first', 'second'])
 
95
            self.assertEqual(['first'], self.activeattributes[tempattribute])
 
96
        finally:
 
97
            # remove the plugin 'plugin'
 
98
            del self.activeattributes[tempattribute]
 
99
            if 'bzrlib.plugins.plugin' in sys.modules:
 
100
                del sys.modules['bzrlib.plugins.plugin']
 
101
            if getattr(bzrlib.plugins, 'plugin', None):
 
102
                del bzrlib.plugins.plugin
 
103
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
104
 
 
105
    def test_plugins_from_different_dirs_can_demand_load(self):
 
106
        # This test tests that having two plugins in different
 
107
        # directories with different names allows them both to be loaded, when
 
108
        # we do a direct import statement.
 
109
        # Determine a file name we can use which is also a valid attribute
 
110
        # for accessing in activeattributes. - we cannot give import parameters.
 
111
        tempattribute = "different-dirs"
 
112
        self.failIf(tempattribute in self.activeattributes)
 
113
        # set a place for the plugins to record their loading, and at the same
 
114
        # time validate that the location the plugins should record to is
 
115
        # valid and correct.
 
116
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
117
            [tempattribute] = []
 
118
        self.failUnless(tempattribute in self.activeattributes)
 
119
        # create two plugin directories
 
120
        os.mkdir('first')
 
121
        os.mkdir('second')
 
122
        # write plugins that will record when they are loaded in the 
 
123
        # tempattribute list.
 
124
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
125
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
126
 
 
127
        outfile = open(os.path.join('first', 'pluginone.py'), 'w')
 
128
        try:
 
129
            outfile.write(template % (tempattribute, 'first'))
 
130
            outfile.write('\n')
 
131
        finally:
 
132
            outfile.close()
 
133
 
 
134
        outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
 
135
        try:
 
136
            outfile.write(template % (tempattribute, 'second'))
 
137
            outfile.write('\n')
 
138
        finally:
 
139
            outfile.close()
 
140
 
 
141
        oldpath = bzrlib.plugins.__path__
 
142
        try:
 
143
            bzrlib.plugins.__path__ = ['first', 'second']
 
144
            exec "import bzrlib.plugins.pluginone"
 
145
            self.assertEqual(['first'], self.activeattributes[tempattribute])
 
146
            exec "import bzrlib.plugins.plugintwo"
 
147
            self.assertEqual(['first', 'second'],
 
148
                self.activeattributes[tempattribute])
 
149
        finally:
 
150
            # remove the plugin 'plugin'
 
151
            del self.activeattributes[tempattribute]
 
152
            if getattr(bzrlib.plugins, 'pluginone', None):
 
153
                del bzrlib.plugins.pluginone
 
154
            if getattr(bzrlib.plugins, 'plugintwo', None):
 
155
                del bzrlib.plugins.plugintwo
 
156
        self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
 
157
        self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
 
158
 
 
159
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
 
160
        # This test tests that a plugin can load from a directory when the
 
161
        # directory in the path has a trailing slash.
 
162
        # check the plugin is not loaded already
 
163
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
164
        tempattribute = "trailing-slash"
 
165
        self.failIf(tempattribute in self.activeattributes)
 
166
        # set a place for the plugin to record its loading, and at the same
 
167
        # time validate that the location the plugin should record to is
 
168
        # valid and correct.
 
169
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
170
            [tempattribute] = []
 
171
        self.failUnless(tempattribute in self.activeattributes)
 
172
        # create a directory for the plugin
 
173
        os.mkdir('plugin_test')
 
174
        # write a plugin that will record when its loaded in the 
 
175
        # tempattribute list.
 
176
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
177
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
178
 
 
179
        outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
 
180
        try:
 
181
            outfile.write(template % (tempattribute, 'plugin'))
 
182
            outfile.write('\n')
 
183
        finally:
 
184
            outfile.close()
 
185
 
 
186
        try:
 
187
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
 
188
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
 
189
        finally:
 
190
            # remove the plugin 'plugin'
 
191
            del self.activeattributes[tempattribute]
 
192
            if getattr(bzrlib.plugins, 'ts_plugin', None):
 
193
                del bzrlib.plugins.ts_plugin
 
194
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
195
 
 
196
    def load_and_capture(self, name):
 
197
        """Load plugins from '.' capturing the output.
 
198
        
 
199
        :param name: The name of the plugin.
 
200
        :return: A string with the log from the plugin loading call.
 
201
        """
 
202
        # Capture output
 
203
        stream = StringIO()
 
204
        try:
 
205
            handler = logging.StreamHandler(stream)
 
206
            log = logging.getLogger('bzr')
 
207
            log.addHandler(handler)
 
208
            try:
 
209
                try:
 
210
                    bzrlib.plugin.load_from_path(['.'])
 
211
                finally:
 
212
                    if 'bzrlib.plugins.%s' % name in sys.modules:
 
213
                        del sys.modules['bzrlib.plugins.%s' % name]
 
214
                    if getattr(bzrlib.plugins, name, None):
 
215
                        delattr(bzrlib.plugins, name)
 
216
            finally:
 
217
                # Stop capturing output
 
218
                handler.flush()
 
219
                handler.close()
 
220
                log.removeHandler(handler)
 
221
            return stream.getvalue()
 
222
        finally:
 
223
            stream.close()
 
224
    
 
225
    def test_plugin_with_bad_api_version_reports(self):
 
226
        # This plugin asks for bzrlib api version 1.0.0, which is not supported
 
227
        # anymore.
 
228
        name = 'wants100.py'
 
229
        f = file(name, 'w')
 
230
        try:
 
231
            f.write("import bzrlib.api\n"
 
232
                "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
 
233
        finally:
 
234
            f.close()
 
235
 
 
236
        log = self.load_and_capture(name)
 
237
        self.assertContainsRe(log,
 
238
            r"It requested API version")
 
239
 
 
240
    def test_plugin_with_bad_name_does_not_load(self):
 
241
        # The file name here invalid for a python module.
 
242
        name = 'bzr-bad plugin-name..py'
 
243
        file(name, 'w').close()
 
244
        log = self.load_and_capture(name)
 
245
        self.assertContainsRe(log,
 
246
            r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
 
247
            "because the file path isn't a valid module name; try renaming "
 
248
            "it to 'bad_plugin_name_'\.")
 
249
 
 
250
 
 
251
class TestPlugins(TestCaseInTempDir):
 
252
 
 
253
    def setup_plugin(self, source=""):
 
254
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
 
255
        # check the plugin is not loaded already
 
256
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
257
        # write a plugin that _cannot_ fail to load.
 
258
        file('plugin.py', 'w').write(source + '\n')
 
259
        self.addCleanup(self.teardown_plugin)
 
260
        bzrlib.plugin.load_from_path(['.'])
 
261
    
 
262
    def teardown_plugin(self):
 
263
        # remove the plugin 'plugin'
 
264
        if 'bzrlib.plugins.plugin' in sys.modules:
 
265
            del sys.modules['bzrlib.plugins.plugin']
 
266
        if getattr(bzrlib.plugins, 'plugin', None):
 
267
            del bzrlib.plugins.plugin
 
268
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
269
 
 
270
    def test_plugin_appears_in_plugins(self):
 
271
        self.setup_plugin()
 
272
        self.failUnless('plugin' in bzrlib.plugin.plugins())
 
273
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
 
274
        plugins = bzrlib.plugin.plugins()
 
275
        plugin = plugins['plugin']
 
276
        self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
 
277
        self.assertEqual(bzrlib.plugins.plugin, plugin.module)
 
278
 
 
279
    def test_trivial_plugin_get_path(self):
 
280
        self.setup_plugin()
 
281
        plugins = bzrlib.plugin.plugins()
 
282
        plugin = plugins['plugin']
 
283
        plugin_path = self.test_dir + '/plugin.py'
 
284
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
285
 
 
286
    def test_plugin_get_path_py_not_pyc(self):
 
287
        self.setup_plugin()         # after first import there will be plugin.pyc
 
288
        self.teardown_plugin()
 
289
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
 
290
        plugins = bzrlib.plugin.plugins()
 
291
        plugin = plugins['plugin']
 
292
        plugin_path = self.test_dir + '/plugin.py'
 
293
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
294
 
 
295
    def test_plugin_get_path_pyc_only(self):
 
296
        self.setup_plugin()         # after first import there will be plugin.pyc
 
297
        self.teardown_plugin()
 
298
        os.unlink(self.test_dir + '/plugin.py')
 
299
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
 
300
        plugins = bzrlib.plugin.plugins()
 
301
        plugin = plugins['plugin']
 
302
        if __debug__:
 
303
            plugin_path = self.test_dir + '/plugin.pyc'
 
304
        else:
 
305
            plugin_path = self.test_dir + '/plugin.pyo'
 
306
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
307
 
 
308
    def test_no_test_suite_gives_None_for_test_suite(self):
 
309
        self.setup_plugin()
 
310
        plugin = bzrlib.plugin.plugins()['plugin']
 
311
        self.assertEqual(None, plugin.test_suite())
 
312
 
 
313
    def test_test_suite_gives_test_suite_result(self):
 
314
        source = """def test_suite(): return 'foo'"""
 
315
        self.setup_plugin(source)
 
316
        plugin = bzrlib.plugin.plugins()['plugin']
 
317
        self.assertEqual('foo', plugin.test_suite())
 
318
 
 
319
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
 
320
        self.setup_plugin()
 
321
        loader = TestUtil.TestLoader()
 
322
        plugin = bzrlib.plugin.plugins()['plugin']
 
323
        self.assertEqual(None, plugin.load_plugin_tests(loader))
 
324
 
 
325
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
 
326
        source = """
 
327
def load_tests(standard_tests, module, loader):
 
328
    return 'foo'"""
 
329
        self.setup_plugin(source)
 
330
        loader = TestUtil.TestLoader()
 
331
        plugin = bzrlib.plugin.plugins()['plugin']
 
332
        self.assertEqual('foo', plugin.load_plugin_tests(loader))
 
333
 
 
334
    def test_no_version_info(self):
 
335
        self.setup_plugin()
 
336
        plugin = bzrlib.plugin.plugins()['plugin']
 
337
        self.assertEqual(None, plugin.version_info())
 
338
 
 
339
    def test_with_version_info(self):
 
340
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
 
341
        plugin = bzrlib.plugin.plugins()['plugin']
 
342
        self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
 
343
 
 
344
    def test_short_version_info_gets_padded(self):
 
345
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
 
346
        # so we adapt it
 
347
        self.setup_plugin("version_info = (1, 2, 3)")
 
348
        plugin = bzrlib.plugin.plugins()['plugin']
 
349
        self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
 
350
 
 
351
    def test_no_version_info___version__(self):
 
352
        self.setup_plugin()
 
353
        plugin = bzrlib.plugin.plugins()['plugin']
 
354
        self.assertEqual("unknown", plugin.__version__)
 
355
 
 
356
    def test___version__with_version_info(self):
 
357
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
 
358
        plugin = bzrlib.plugin.plugins()['plugin']
 
359
        self.assertEqual("1.2.3dev4", plugin.__version__)
 
360
 
 
361
    def test_final__version__with_version_info(self):
 
362
        self.setup_plugin("version_info = (1, 2, 3, 'final', 4)")
 
363
        plugin = bzrlib.plugin.plugins()['plugin']
 
364
        self.assertEqual("1.2.3", plugin.__version__)
 
365
 
 
366
 
 
367
class TestPluginHelp(TestCaseInTempDir):
 
368
 
 
369
    def split_help_commands(self):
 
370
        help = {}
 
371
        current = None
 
372
        for line in self.run_bzr('help commands')[0].splitlines():
 
373
            if not line.startswith(' '):
 
374
                current = line.split()[0]
 
375
            help[current] = help.get(current, '') + line
 
376
 
 
377
        return help
 
378
 
 
379
    def test_plugin_help_builtins_unaffected(self):
 
380
        # Check we don't get false positives
 
381
        help_commands = self.split_help_commands()
 
382
        for cmd_name in bzrlib.commands.builtin_command_names():
 
383
            if cmd_name in bzrlib.commands.plugin_command_names():
 
384
                continue
 
385
            try:
 
386
                help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
 
387
            except NotImplementedError:
 
388
                # some commands have no help
 
389
                pass
 
390
            else:
 
391
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
 
392
 
 
393
            if cmd_name in help_commands.keys():
 
394
                # some commands are hidden
 
395
                help = help_commands[cmd_name]
 
396
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
 
397
 
 
398
    def test_plugin_help_shows_plugin(self):
 
399
        # Create a test plugin
 
400
        os.mkdir('plugin_test')
 
401
        f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
 
402
        f.write(PLUGIN_TEXT)
 
403
        f.close()
 
404
 
 
405
        try:
 
406
            # Check its help
 
407
            bzrlib.plugin.load_from_path(['plugin_test'])
 
408
            bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
 
409
            help = self.run_bzr('help myplug')[0]
 
410
            self.assertContainsRe(help, 'plugin "myplug"')
 
411
            help = self.split_help_commands()['myplug']
 
412
            self.assertContainsRe(help, '\[myplug\]')
 
413
        finally:
 
414
            # unregister command
 
415
            if 'myplug' in bzrlib.commands.plugin_cmds:
 
416
                bzrlib.commands.plugin_cmds.remove('myplug')
 
417
            # remove the plugin 'myplug'
 
418
            if getattr(bzrlib.plugins, 'myplug', None):
 
419
                delattr(bzrlib.plugins, 'myplug')
 
420
 
 
421
 
 
422
class TestPluginFromZip(TestCaseInTempDir):
 
423
 
 
424
    def make_zipped_plugin(self, zip_name, filename):
 
425
        z = zipfile.ZipFile(zip_name, 'w')
 
426
        z.writestr(filename, PLUGIN_TEXT)
 
427
        z.close()
 
428
 
 
429
    def check_plugin_load(self, zip_name, plugin_name):
 
430
        self.assertFalse(plugin_name in dir(bzrlib.plugins),
 
431
                         'Plugin already loaded')
 
432
        old_path = bzrlib.plugins.__path__
 
433
        try:
 
434
            # this is normally done by load_plugins -> set_plugins_path
 
435
            bzrlib.plugins.__path__ = [zip_name]
 
436
            self.applyDeprecated(one_three,
 
437
                bzrlib.plugin.load_from_zip, zip_name)
 
438
            self.assertTrue(plugin_name in dir(bzrlib.plugins),
 
439
                            'Plugin is not loaded')
 
440
        finally:
 
441
            # unregister plugin
 
442
            if getattr(bzrlib.plugins, plugin_name, None):
 
443
                delattr(bzrlib.plugins, plugin_name)
 
444
                del sys.modules['bzrlib.plugins.' + plugin_name]
 
445
            bzrlib.plugins.__path__ = old_path
 
446
 
 
447
    def test_load_module(self):
 
448
        self.make_zipped_plugin('./test.zip', 'ziplug.py')
 
449
        self.check_plugin_load('./test.zip', 'ziplug')
 
450
 
 
451
    def test_load_package(self):
 
452
        self.make_zipped_plugin('./test.zip', 'ziplug/__init__.py')
 
453
        self.check_plugin_load('./test.zip', 'ziplug')
 
454
 
 
455
 
 
456
class TestSetPluginsPath(TestCase):
 
457
    
 
458
    def test_set_plugins_path(self):
 
459
        """set_plugins_path should set the module __path__ correctly."""
 
460
        old_path = bzrlib.plugins.__path__
 
461
        try:
 
462
            bzrlib.plugins.__path__ = []
 
463
            expected_path = bzrlib.plugin.set_plugins_path()
 
464
            self.assertEqual(expected_path, bzrlib.plugins.__path__)
 
465
        finally:
 
466
            bzrlib.plugins.__path__ = old_path
 
467
 
 
468
    def test_set_plugins_path_with_trailing_slashes(self):
 
469
        """set_plugins_path should set the module __path__ based on
 
470
        BZR_PLUGIN_PATH after removing all trailing slashes."""
 
471
        old_path = bzrlib.plugins.__path__
 
472
        old_env = os.environ.get('BZR_PLUGIN_PATH')
 
473
        try:
 
474
            bzrlib.plugins.__path__ = []
 
475
            os.environ['BZR_PLUGIN_PATH'] = "first\\//\\" + os.pathsep + \
 
476
                "second/\\/\\/"
 
477
            bzrlib.plugin.set_plugins_path()
 
478
            # We expect our nominated paths to have all path-seps removed,
 
479
            # and this is testing only that.
 
480
            expected_path = ['first', 'second']
 
481
            self.assertEqual(expected_path,
 
482
                bzrlib.plugins.__path__[:len(expected_path)])
 
483
        finally:
 
484
            bzrlib.plugins.__path__ = old_path
 
485
            if old_env is not None:
 
486
                os.environ['BZR_PLUGIN_PATH'] = old_env
 
487
            else:
 
488
                del os.environ['BZR_PLUGIN_PATH']
 
489
 
 
490
 
 
491
class TestHelpIndex(tests.TestCase):
 
492
    """Tests for the PluginsHelpIndex class."""
 
493
 
 
494
    def test_default_constructable(self):
 
495
        index = plugin.PluginsHelpIndex()
 
496
 
 
497
    def test_get_topics_None(self):
 
498
        """Searching for None returns an empty list."""
 
499
        index = plugin.PluginsHelpIndex()
 
500
        self.assertEqual([], index.get_topics(None))
 
501
 
 
502
    def test_get_topics_for_plugin(self):
 
503
        """Searching for plugin name gets its docstring."""
 
504
        index = plugin.PluginsHelpIndex()
 
505
        # make a new plugin here for this test, even if we're run with
 
506
        # --no-plugins
 
507
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
 
508
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
 
509
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
510
        try:
 
511
            topics = index.get_topics('demo_module')
 
512
            self.assertEqual(1, len(topics))
 
513
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
 
514
            self.assertEqual(demo_module, topics[0].module)
 
515
        finally:
 
516
            del sys.modules['bzrlib.plugins.demo_module']
 
517
 
 
518
    def test_get_topics_no_topic(self):
 
519
        """Searching for something that is not a plugin returns []."""
 
520
        # test this by using a name that cannot be a plugin - its not
 
521
        # a valid python identifier.
 
522
        index = plugin.PluginsHelpIndex()
 
523
        self.assertEqual([], index.get_topics('nothing by this name'))
 
524
 
 
525
    def test_prefix(self):
 
526
        """PluginsHelpIndex has a prefix of 'plugins/'."""
 
527
        index = plugin.PluginsHelpIndex()
 
528
        self.assertEqual('plugins/', index.prefix)
 
529
 
 
530
    def test_get_plugin_topic_with_prefix(self):
 
531
        """Searching for plugins/demo_module returns help."""
 
532
        index = plugin.PluginsHelpIndex()
 
533
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
 
534
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
 
535
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
536
        try:
 
537
            topics = index.get_topics('plugins/demo_module')
 
538
            self.assertEqual(1, len(topics))
 
539
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
 
540
            self.assertEqual(demo_module, topics[0].module)
 
541
        finally:
 
542
            del sys.modules['bzrlib.plugins.demo_module']
 
543
 
 
544
 
 
545
class FakeModule(object):
 
546
    """A fake module to test with."""
 
547
 
 
548
    def __init__(self, doc, name):
 
549
        self.__doc__ = doc
 
550
        self.__name__ = name
 
551
 
 
552
 
 
553
class TestModuleHelpTopic(tests.TestCase):
 
554
    """Tests for the ModuleHelpTopic class."""
 
555
 
 
556
    def test_contruct(self):
 
557
        """Construction takes the module to document."""
 
558
        mod = FakeModule('foo', 'foo')
 
559
        topic = plugin.ModuleHelpTopic(mod)
 
560
        self.assertEqual(mod, topic.module)
 
561
 
 
562
    def test_get_help_text_None(self):
 
563
        """A ModuleHelpTopic returns the docstring for get_help_text."""
 
564
        mod = FakeModule(None, 'demo')
 
565
        topic = plugin.ModuleHelpTopic(mod)
 
566
        self.assertEqual("Plugin 'demo' has no docstring.\n",
 
567
            topic.get_help_text())
 
568
 
 
569
    def test_get_help_text_no_carriage_return(self):
 
570
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
 
571
        mod = FakeModule('one line of help', 'demo')
 
572
        topic = plugin.ModuleHelpTopic(mod)
 
573
        self.assertEqual("one line of help\n",
 
574
            topic.get_help_text())
 
575
 
 
576
    def test_get_help_text_carriage_return(self):
 
577
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
 
578
        mod = FakeModule('two lines of help\nand more\n', 'demo')
 
579
        topic = plugin.ModuleHelpTopic(mod)
 
580
        self.assertEqual("two lines of help\nand more\n",
 
581
            topic.get_help_text())
 
582
 
 
583
    def test_get_help_text_with_additional_see_also(self):
 
584
        mod = FakeModule('two lines of help\nand more', 'demo')
 
585
        topic = plugin.ModuleHelpTopic(mod)
 
586
        self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
 
587
            topic.get_help_text(['foo', 'bar']))
 
588
 
 
589
    def test_get_help_topic(self):
 
590
        """The help topic for a plugin is its module name."""
 
591
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
 
592
        topic = plugin.ModuleHelpTopic(mod)
 
593
        self.assertEqual('demo', topic.get_help_topic())
 
594
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
 
595
        topic = plugin.ModuleHelpTopic(mod)
 
596
        self.assertEqual('foo_bar', topic.get_help_topic())