← 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: Jelmer Vernooij
  • Date: 2011-02-26 15:39:49 UTC
  • mto: (5691.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 5692.
  • Revision ID: jelmer@samba.org-20110226153949-o0fk909b30g7z570
https://launchpad.net/bugs/397556
Fix the use of "bzr tags" in branches with ghosts in their mainline /and/ tags on revisions not in the branch ancestry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005-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
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
16
 
 
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
"""Tests for plugins"""
19
18
 
21
20
# affects the global state of the process.  See bzrlib/plugins.py for more
22
21
# comments.
23
22
 
 
23
from cStringIO import StringIO
 
24
import logging
24
25
import os
25
 
from StringIO import StringIO
26
 
 
27
 
import bzrlib.plugin
28
 
import bzrlib.plugins
29
 
import bzrlib.commands
30
 
import bzrlib.help
31
 
from bzrlib.tests import TestCaseInTempDir
32
 
from bzrlib.osutils import pathjoin, abspath
33
 
 
34
 
class PluginTest(TestCaseInTempDir):
35
 
    """Create an external plugin and test loading."""
36
 
#    def test_plugin_loading(self):
37
 
#        orig_help = self.run_bzr_captured('bzr help commands')[0]
38
 
#        os.mkdir('plugin_test')
39
 
#        f = open(pathjoin('plugin_test', 'myplug.py'), 'wt')
40
 
#        f.write(PLUGIN_TEXT)
41
 
#        f.close()
42
 
#        newhelp = self.run_bzr_captured('bzr help commands')[0]
43
 
#        assert newhelp.startswith('You have been overridden\n')
44
 
#        # We added a line, but the rest should work
45
 
#        assert newhelp[25:] == help
46
 
#
47
 
#        assert backtick('bzr commit -m test') == "I'm sorry dave, you can't do that\n"
48
 
#
49
 
#        shutil.rmtree('plugin_test')
50
 
#
51
 
 
52
 
#         os.environ['BZRPLUGINPATH'] = abspath('plugin_test')
53
 
#         help = backtick('bzr help commands')
54
 
#         assert help.find('myplug') != -1
55
 
#         assert help.find('Just a simple test plugin.') != -1
56
 
 
57
 
 
58
 
#         assert backtick('bzr myplug') == 'Hello from my plugin\n'
59
 
#         assert backtick('bzr mplg') == 'Hello from my plugin\n'
60
 
 
61
 
#         f = open(pathjoin('plugin_test', 'override.py'), 'wb')
62
 
#         f.write("""import bzrlib, bzrlib.commands
63
 
#     class cmd_commit(bzrlib.commands.cmd_commit):
64
 
#         '''Commit changes into a new revision.'''
65
 
#         def run(self, *args, **kwargs):
66
 
#             print "I'm sorry dave, you can't do that"
67
 
 
68
 
#     class cmd_help(bzrlib.commands.cmd_help):
69
 
#         '''Show help on a command or other topic.'''
70
 
#         def run(self, *args, **kwargs):
71
 
#             print "You have been overridden"
72
 
#             bzrlib.commands.cmd_help.run(self, *args, **kwargs)
73
 
 
74
 
#         """
75
 
 
76
 
PLUGIN_TEXT = """\
77
 
import bzrlib.commands
78
 
class cmd_myplug(bzrlib.commands.Command):
79
 
    '''Just a simple test plugin.'''
80
 
    aliases = ['mplg']
81
 
    def run(self):
82
 
        print 'Hello from my plugin'
83
 
"""
 
26
import sys
 
27
 
 
28
import bzrlib
 
29
from bzrlib import (
 
30
    errors,
 
31
    osutils,
 
32
    plugin,
 
33
    plugins,
 
34
    tests,
 
35
    trace,
 
36
    )
 
37
 
84
38
 
85
39
# TODO: Write a test for plugin decoration of commands.
86
40
 
87
 
class TestOneNamedPluginOnly(TestCaseInTempDir):
 
41
class BaseTestPlugins(tests.TestCaseInTempDir):
 
42
 
 
43
    def create_plugin(self, name, source=None, dir='.', file_name=None):
 
44
        if source is None:
 
45
            source = '''\
 
46
"""This is the doc for %s"""
 
47
''' % (name)
 
48
        if file_name is None:
 
49
            file_name = name + '.py'
 
50
        # 'source' must not fail to load
 
51
        path = osutils.pathjoin(dir, file_name)
 
52
        f = open(path, 'w')
 
53
        self.addCleanup(os.unlink, path)
 
54
        try:
 
55
            f.write(source + '\n')
 
56
        finally:
 
57
            f.close()
 
58
 
 
59
    def create_plugin_package(self, name, dir=None, source=None):
 
60
        if dir is None:
 
61
            dir = name
 
62
        if source is None:
 
63
            source = '''\
 
64
"""This is the doc for %s"""
 
65
dir_source = '%s'
 
66
''' % (name, dir)
 
67
        os.makedirs(dir)
 
68
        def cleanup():
 
69
            # Workaround lazy import random? madness
 
70
            osutils.rmtree(dir)
 
71
        self.addCleanup(cleanup)
 
72
        self.create_plugin(name, source, dir,
 
73
                           file_name='__init__.py')
 
74
 
 
75
    def _unregister_plugin(self, name):
 
76
        """Remove the plugin from sys.modules and the bzrlib namespace."""
 
77
        py_name = 'bzrlib.plugins.%s' % name
 
78
        if py_name in sys.modules:
 
79
            del sys.modules[py_name]
 
80
        if getattr(bzrlib.plugins, name, None) is not None:
 
81
            delattr(bzrlib.plugins, name)
 
82
 
 
83
    def _unregister_plugin_submodule(self, plugin_name, submodule_name):
 
84
        """Remove the submodule from sys.modules and the bzrlib namespace."""
 
85
        py_name = 'bzrlib.plugins.%s.%s' % (plugin_name, submodule_name)
 
86
        if py_name in sys.modules:
 
87
            del sys.modules[py_name]
 
88
        plugin = getattr(bzrlib.plugins, plugin_name, None)
 
89
        if plugin is not None:
 
90
            if getattr(plugin, submodule_name, None) is not None:
 
91
                delattr(plugin, submodule_name)
 
92
 
 
93
    def assertPluginUnknown(self, name):
 
94
        self.failIf(getattr(bzrlib.plugins, name, None) is not None)
 
95
        self.failIf('bzrlib.plugins.%s' % name in sys.modules)
 
96
 
 
97
    def assertPluginKnown(self, name):
 
98
        self.failUnless(getattr(bzrlib.plugins, name, None) is not None)
 
99
        self.failUnless('bzrlib.plugins.%s' % name in sys.modules)
 
100
 
 
101
 
 
102
class TestLoadingPlugins(BaseTestPlugins):
88
103
 
89
104
    activeattributes = {}
90
105
 
91
106
    def test_plugins_with_the_same_name_are_not_loaded(self):
 
107
        # This test tests that having two plugins in different directories does
 
108
        # not result in both being loaded when they have the same name.  get a
 
109
        # file name we can use which is also a valid attribute for accessing in
 
110
        # activeattributes. - we cannot give import parameters.
 
111
        tempattribute = "0"
 
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
        self.__class__.activeattributes [tempattribute] = []
 
117
        self.failUnless(tempattribute in self.activeattributes)
 
118
        # create two plugin directories
 
119
        os.mkdir('first')
 
120
        os.mkdir('second')
 
121
        # write a plugin that will record when its loaded in the
 
122
        # tempattribute list.
 
123
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
124
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
125
 
 
126
        outfile = open(os.path.join('first', 'plugin.py'), 'w')
 
127
        try:
 
128
            outfile.write(template % (tempattribute, 'first'))
 
129
            outfile.write('\n')
 
130
        finally:
 
131
            outfile.close()
 
132
 
 
133
        outfile = open(os.path.join('second', 'plugin.py'), 'w')
 
134
        try:
 
135
            outfile.write(template % (tempattribute, 'second'))
 
136
            outfile.write('\n')
 
137
        finally:
 
138
            outfile.close()
 
139
 
 
140
        try:
 
141
            bzrlib.plugin.load_from_path(['first', 'second'])
 
142
            self.assertEqual(['first'], self.activeattributes[tempattribute])
 
143
        finally:
 
144
            # remove the plugin 'plugin'
 
145
            del self.activeattributes[tempattribute]
 
146
            self._unregister_plugin('plugin')
 
147
        self.assertPluginUnknown('plugin')
 
148
 
 
149
    def test_plugins_from_different_dirs_can_demand_load(self):
 
150
        self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
151
        self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
92
152
        # This test tests that having two plugins in different
93
 
        # directories does not result in both being loaded.
94
 
        # get a file name we can use which is also a valid attribute
 
153
        # directories with different names allows them both to be loaded, when
 
154
        # we do a direct import statement.
 
155
        # Determine a file name we can use which is also a valid attribute
95
156
        # for accessing in activeattributes. - we cannot give import parameters.
96
 
        tempattribute = "0"
 
157
        tempattribute = "different-dirs"
97
158
        self.failIf(tempattribute in self.activeattributes)
98
159
        # set a place for the plugins to record their loading, and at the same
99
160
        # time validate that the location the plugins should record to is
100
161
        # valid and correct.
101
 
        bzrlib.tests.test_plugins.TestOneNamedPluginOnly.activeattributes \
 
162
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
102
163
            [tempattribute] = []
103
164
        self.failUnless(tempattribute in self.activeattributes)
104
165
        # create two plugin directories
105
166
        os.mkdir('first')
106
167
        os.mkdir('second')
107
 
        # write a plugin that will record when its loaded in the 
 
168
        # write plugins that will record when they are loaded in the
108
169
        # tempattribute list.
109
 
        template = ("from bzrlib.tests.test_plugins import TestOneNamedPluginOnly\n"
110
 
                    "TestOneNamedPluginOnly.activeattributes[%r].append('%s')\n")
111
 
        print >> file(os.path.join('first', 'plugin.py'), 'w'), template % (tempattribute, 'first')
112
 
        print >> file(os.path.join('second', 'plugin.py'), 'w'), template % (tempattribute, 'second')
113
 
        try:
114
 
            bzrlib.plugin.load_from_dirs(['first', 'second'])
 
170
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
171
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
172
 
 
173
        outfile = open(os.path.join('first', 'pluginone.py'), 'w')
 
174
        try:
 
175
            outfile.write(template % (tempattribute, 'first'))
 
176
            outfile.write('\n')
 
177
        finally:
 
178
            outfile.close()
 
179
 
 
180
        outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
 
181
        try:
 
182
            outfile.write(template % (tempattribute, 'second'))
 
183
            outfile.write('\n')
 
184
        finally:
 
185
            outfile.close()
 
186
 
 
187
        oldpath = bzrlib.plugins.__path__
 
188
        try:
 
189
            self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
190
            self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
 
191
            bzrlib.plugins.__path__ = ['first', 'second']
 
192
            exec "import bzrlib.plugins.pluginone"
115
193
            self.assertEqual(['first'], self.activeattributes[tempattribute])
 
194
            exec "import bzrlib.plugins.plugintwo"
 
195
            self.assertEqual(['first', 'second'],
 
196
                self.activeattributes[tempattribute])
116
197
        finally:
117
198
            # remove the plugin 'plugin'
118
199
            del self.activeattributes[tempattribute]
119
 
            if getattr(bzrlib.plugins, 'plugin', None):
120
 
                del bzrlib.plugins.plugin
121
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
122
 
 
123
 
 
124
 
class TestAllPlugins(TestCaseInTempDir):
125
 
 
126
 
    def test_plugin_appears_in_all_plugins(self):
127
 
        # This test tests a new plugin appears in bzrlib.plugin.all_plugins().
128
 
        # check the plugin is not loaded already
129
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
200
            self._unregister_plugin('pluginone')
 
201
            self._unregister_plugin('plugintwo')
 
202
        self.assertPluginUnknown('pluginone')
 
203
        self.assertPluginUnknown('plugintwo')
 
204
 
 
205
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
 
206
        # This test tests that a plugin can load from a directory when the
 
207
        # directory in the path has a trailing slash.
 
208
        # check the plugin is not loaded already
 
209
        self.assertPluginUnknown('ts_plugin')
 
210
        tempattribute = "trailing-slash"
 
211
        self.failIf(tempattribute in self.activeattributes)
 
212
        # set a place for the plugin to record its loading, and at the same
 
213
        # time validate that the location the plugin should record to is
 
214
        # valid and correct.
 
215
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
216
            [tempattribute] = []
 
217
        self.failUnless(tempattribute in self.activeattributes)
 
218
        # create a directory for the plugin
 
219
        os.mkdir('plugin_test')
 
220
        # write a plugin that will record when its loaded in the
 
221
        # tempattribute list.
 
222
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
223
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
 
224
 
 
225
        outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
 
226
        try:
 
227
            outfile.write(template % (tempattribute, 'plugin'))
 
228
            outfile.write('\n')
 
229
        finally:
 
230
            outfile.close()
 
231
 
 
232
        try:
 
233
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
 
234
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
 
235
        finally:
 
236
            del self.activeattributes[tempattribute]
 
237
            self._unregister_plugin('ts_plugin')
 
238
        self.assertPluginUnknown('ts_plugin')
 
239
 
 
240
    def load_and_capture(self, name):
 
241
        """Load plugins from '.' capturing the output.
 
242
 
 
243
        :param name: The name of the plugin.
 
244
        :return: A string with the log from the plugin loading call.
 
245
        """
 
246
        # Capture output
 
247
        stream = StringIO()
 
248
        try:
 
249
            handler = logging.StreamHandler(stream)
 
250
            log = logging.getLogger('bzr')
 
251
            log.addHandler(handler)
 
252
            try:
 
253
                try:
 
254
                    bzrlib.plugin.load_from_path(['.'])
 
255
                finally:
 
256
                    if 'bzrlib.plugins.%s' % name in sys.modules:
 
257
                        del sys.modules['bzrlib.plugins.%s' % name]
 
258
                    if getattr(bzrlib.plugins, name, None):
 
259
                        delattr(bzrlib.plugins, name)
 
260
            finally:
 
261
                # Stop capturing output
 
262
                handler.flush()
 
263
                handler.close()
 
264
                log.removeHandler(handler)
 
265
            return stream.getvalue()
 
266
        finally:
 
267
            stream.close()
 
268
 
 
269
    def test_plugin_with_bad_api_version_reports(self):
 
270
        """Try loading a plugin that requests an unsupported api.
 
271
        
 
272
        Observe that it records the problem but doesn't complain on stderr.
 
273
 
 
274
        See https://bugs.launchpad.net/bzr/+bug/704195
 
275
        """
 
276
        self.overrideAttr(plugin, 'plugin_warnings', {})
 
277
        name = 'wants100.py'
 
278
        f = file(name, 'w')
 
279
        try:
 
280
            f.write("import bzrlib.api\n"
 
281
                "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
 
282
        finally:
 
283
            f.close()
 
284
        log = self.load_and_capture(name)
 
285
        self.assertNotContainsRe(log,
 
286
            r"It requested API version")
 
287
        self.assertEquals(
 
288
            ['wants100'],
 
289
            plugin.plugin_warnings.keys())
 
290
        self.assertContainsRe(
 
291
            plugin.plugin_warnings['wants100'][0],
 
292
            r"It requested API version")
 
293
 
 
294
    def test_plugin_with_bad_name_does_not_load(self):
 
295
        # The file name here invalid for a python module.
 
296
        name = 'bzr-bad plugin-name..py'
 
297
        file(name, 'w').close()
 
298
        log = self.load_and_capture(name)
 
299
        self.assertContainsRe(log,
 
300
            r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
 
301
            "because the file path isn't a valid module name; try renaming "
 
302
            "it to 'bad_plugin_name_'\.")
 
303
 
 
304
 
 
305
class TestPlugins(BaseTestPlugins):
 
306
 
 
307
    def setup_plugin(self, source=""):
 
308
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
 
309
        # check the plugin is not loaded already
 
310
        self.assertPluginUnknown('plugin')
130
311
        # write a plugin that _cannot_ fail to load.
131
 
        print >> file('plugin.py', 'w'), ""
132
 
        try:
133
 
            bzrlib.plugin.load_from_dirs(['.'])
134
 
            self.failUnless('plugin' in bzrlib.plugin.all_plugins())
135
 
            self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
136
 
            self.assertEqual(bzrlib.plugin.all_plugins()['plugin'],
137
 
                             bzrlib.plugins.plugin)
138
 
        finally:
139
 
            # remove the plugin 'plugin'
140
 
            if getattr(bzrlib.plugins, 'plugin', None):
141
 
                del bzrlib.plugins.plugin
142
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
143
 
 
144
 
 
145
 
class TestPluginHelp(TestCaseInTempDir):
 
312
        file('plugin.py', 'w').write(source + '\n')
 
313
        self.addCleanup(self.teardown_plugin)
 
314
        plugin.load_from_path(['.'])
 
315
 
 
316
    def teardown_plugin(self):
 
317
        self._unregister_plugin('plugin')
 
318
        self.assertPluginUnknown('plugin')
 
319
 
 
320
    def test_plugin_appears_in_plugins(self):
 
321
        self.setup_plugin()
 
322
        self.assertPluginKnown('plugin')
 
323
        p = plugin.plugins()['plugin']
 
324
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
 
325
        self.assertEqual(p.module, plugins.plugin)
 
326
 
 
327
    def test_trivial_plugin_get_path(self):
 
328
        self.setup_plugin()
 
329
        p = plugin.plugins()['plugin']
 
330
        plugin_path = self.test_dir + '/plugin.py'
 
331
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
 
332
 
 
333
    def test_plugin_get_path_py_not_pyc(self):
 
334
        # first import creates plugin.pyc
 
335
        self.setup_plugin()
 
336
        self.teardown_plugin()
 
337
        plugin.load_from_path(['.']) # import plugin.pyc
 
338
        p = plugin.plugins()['plugin']
 
339
        plugin_path = self.test_dir + '/plugin.py'
 
340
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
 
341
 
 
342
    def test_plugin_get_path_pyc_only(self):
 
343
        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)
 
344
        self.setup_plugin()
 
345
        self.teardown_plugin()
 
346
        os.unlink(self.test_dir + '/plugin.py')
 
347
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
348
        p = plugin.plugins()['plugin']
 
349
        if __debug__:
 
350
            plugin_path = self.test_dir + '/plugin.pyc'
 
351
        else:
 
352
            plugin_path = self.test_dir + '/plugin.pyo'
 
353
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
 
354
 
 
355
    def test_no_test_suite_gives_None_for_test_suite(self):
 
356
        self.setup_plugin()
 
357
        p = plugin.plugins()['plugin']
 
358
        self.assertEqual(None, p.test_suite())
 
359
 
 
360
    def test_test_suite_gives_test_suite_result(self):
 
361
        source = """def test_suite(): return 'foo'"""
 
362
        self.setup_plugin(source)
 
363
        p = plugin.plugins()['plugin']
 
364
        self.assertEqual('foo', p.test_suite())
 
365
 
 
366
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
 
367
        self.setup_plugin()
 
368
        loader = tests.TestUtil.TestLoader()
 
369
        p = plugin.plugins()['plugin']
 
370
        self.assertEqual(None, p.load_plugin_tests(loader))
 
371
 
 
372
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
 
373
        source = """
 
374
def load_tests(standard_tests, module, loader):
 
375
    return 'foo'"""
 
376
        self.setup_plugin(source)
 
377
        loader = tests.TestUtil.TestLoader()
 
378
        p = plugin.plugins()['plugin']
 
379
        self.assertEqual('foo', p.load_plugin_tests(loader))
 
380
 
 
381
    def check_version_info(self, expected, source='', name='plugin'):
 
382
        self.setup_plugin(source)
 
383
        self.assertEqual(expected, plugin.plugins()[name].version_info())
 
384
 
 
385
    def test_no_version_info(self):
 
386
        self.check_version_info(None)
 
387
 
 
388
    def test_with_version_info(self):
 
389
        self.check_version_info((1, 2, 3, 'dev', 4),
 
390
                                "version_info = (1, 2, 3, 'dev', 4)")
 
391
 
 
392
    def test_short_version_info_gets_padded(self):
 
393
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
 
394
        # so we adapt it
 
395
        self.check_version_info((1, 2, 3, 'final', 0),
 
396
                                "version_info = (1, 2, 3)")
 
397
 
 
398
    def check_version(self, expected, source=None, name='plugin'):
 
399
        self.setup_plugin(source)
 
400
        self.assertEqual(expected, plugins[name].__version__)
 
401
 
 
402
    def test_no_version_info___version__(self):
 
403
        self.setup_plugin()
 
404
        plugin = bzrlib.plugin.plugins()['plugin']
 
405
        self.assertEqual("unknown", plugin.__version__)
 
406
 
 
407
    def test_str__version__with_version_info(self):
 
408
        self.setup_plugin("version_info = '1.2.3'")
 
409
        plugin = bzrlib.plugin.plugins()['plugin']
 
410
        self.assertEqual("1.2.3", plugin.__version__)
 
411
 
 
412
    def test_noniterable__version__with_version_info(self):
 
413
        self.setup_plugin("version_info = (1)")
 
414
        plugin = bzrlib.plugin.plugins()['plugin']
 
415
        self.assertEqual("1", plugin.__version__)
 
416
 
 
417
    def test_1__version__with_version_info(self):
 
418
        self.setup_plugin("version_info = (1,)")
 
419
        plugin = bzrlib.plugin.plugins()['plugin']
 
420
        self.assertEqual("1", plugin.__version__)
 
421
 
 
422
    def test_1_2__version__with_version_info(self):
 
423
        self.setup_plugin("version_info = (1, 2)")
 
424
        plugin = bzrlib.plugin.plugins()['plugin']
 
425
        self.assertEqual("1.2", plugin.__version__)
 
426
 
 
427
    def test_1_2_3__version__with_version_info(self):
 
428
        self.setup_plugin("version_info = (1, 2, 3)")
 
429
        plugin = bzrlib.plugin.plugins()['plugin']
 
430
        self.assertEqual("1.2.3", plugin.__version__)
 
431
 
 
432
    def test_candidate__version__with_version_info(self):
 
433
        self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
 
434
        plugin = bzrlib.plugin.plugins()['plugin']
 
435
        self.assertEqual("1.2.3rc1", plugin.__version__)
 
436
 
 
437
    def test_dev__version__with_version_info(self):
 
438
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
 
439
        plugin = bzrlib.plugin.plugins()['plugin']
 
440
        self.assertEqual("1.2.3dev", plugin.__version__)
 
441
 
 
442
    def test_dev_fallback__version__with_version_info(self):
 
443
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
 
444
        plugin = bzrlib.plugin.plugins()['plugin']
 
445
        self.assertEqual("1.2.3dev4", plugin.__version__)
 
446
 
 
447
    def test_final__version__with_version_info(self):
 
448
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
 
449
        plugin = bzrlib.plugin.plugins()['plugin']
 
450
        self.assertEqual("1.2.3", plugin.__version__)
 
451
 
 
452
    def test_final_fallback__version__with_version_info(self):
 
453
        self.setup_plugin("version_info = (1, 2, 3, 'final', 2)")
 
454
        plugin = bzrlib.plugin.plugins()['plugin']
 
455
        self.assertEqual("1.2.3.final.2", plugin.__version__)
 
456
 
 
457
 
 
458
class TestPluginHelp(tests.TestCaseInTempDir):
146
459
 
147
460
    def split_help_commands(self):
148
461
        help = {}
149
462
        current = None
150
 
        for line in self.capture('help commands').splitlines():
151
 
            if line.startswith('bzr '):
152
 
                current = line.split()[1]
 
463
        out, err = self.run_bzr('--no-plugins help commands')
 
464
        for line in out.splitlines():
 
465
            if not line.startswith(' '):
 
466
                current = line.split()[0]
153
467
            help[current] = help.get(current, '') + line
154
468
 
155
469
        return help
160
474
        for cmd_name in bzrlib.commands.builtin_command_names():
161
475
            if cmd_name in bzrlib.commands.plugin_command_names():
162
476
                continue
163
 
            help = StringIO()
164
477
            try:
165
 
                bzrlib.help.help_on_command(cmd_name, help)
 
478
                help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
166
479
            except NotImplementedError:
167
480
                # some commands have no help
168
481
                pass
169
482
            else:
170
 
                help.seek(0)
171
 
                self.assertNotContainsRe(help.read(), 'From plugin "[^"]*"')
 
483
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
172
484
 
173
 
            if help in help_commands.keys():
 
485
            if cmd_name in help_commands.keys():
174
486
                # some commands are hidden
175
487
                help = help_commands[cmd_name]
176
 
                self.assertNotContainsRe(help, 'From plugin "[^"]*"')
 
488
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
177
489
 
178
490
    def test_plugin_help_shows_plugin(self):
179
491
        # Create a test plugin
180
492
        os.mkdir('plugin_test')
181
 
        f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
182
 
        f.write(PLUGIN_TEXT)
 
493
        f = open(osutils.pathjoin('plugin_test', 'myplug.py'), 'w')
 
494
        f.write("""\
 
495
from bzrlib import commands
 
496
class cmd_myplug(commands.Command):
 
497
    __doc__ = '''Just a simple test plugin.'''
 
498
    aliases = ['mplg']
 
499
    def run(self):
 
500
        print 'Hello from my plugin'
 
501
 
 
502
"""
 
503
)
183
504
        f.close()
184
505
 
185
506
        try:
186
507
            # Check its help
187
 
            bzrlib.plugin.load_from_dirs(['plugin_test'])
 
508
            bzrlib.plugin.load_from_path(['plugin_test'])
188
509
            bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
189
 
            help = self.capture('help myplug')
190
 
            self.assertContainsRe(help, 'From plugin "myplug"')
 
510
            help = self.run_bzr('help myplug')[0]
 
511
            self.assertContainsRe(help, 'plugin "myplug"')
191
512
            help = self.split_help_commands()['myplug']
192
 
            self.assertContainsRe(help, 'From plugin "myplug"')
193
 
        finally:
194
 
            # remove the plugin 'plugin'
195
 
            if getattr(bzrlib.plugins, 'plugin', None):
196
 
                del bzrlib.plugins.plugin
 
513
            self.assertContainsRe(help, '\[myplug\]')
 
514
        finally:
 
515
            # unregister command
 
516
            if 'myplug' in bzrlib.commands.plugin_cmds:
 
517
                bzrlib.commands.plugin_cmds.remove('myplug')
 
518
            # remove the plugin 'myplug'
 
519
            if getattr(bzrlib.plugins, 'myplug', None):
 
520
                delattr(bzrlib.plugins, 'myplug')
 
521
 
 
522
 
 
523
class TestHelpIndex(tests.TestCase):
 
524
    """Tests for the PluginsHelpIndex class."""
 
525
 
 
526
    def test_default_constructable(self):
 
527
        index = plugin.PluginsHelpIndex()
 
528
 
 
529
    def test_get_topics_None(self):
 
530
        """Searching for None returns an empty list."""
 
531
        index = plugin.PluginsHelpIndex()
 
532
        self.assertEqual([], index.get_topics(None))
 
533
 
 
534
    def test_get_topics_for_plugin(self):
 
535
        """Searching for plugin name gets its docstring."""
 
536
        index = plugin.PluginsHelpIndex()
 
537
        # make a new plugin here for this test, even if we're run with
 
538
        # --no-plugins
 
539
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
 
540
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
 
541
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
542
        try:
 
543
            topics = index.get_topics('demo_module')
 
544
            self.assertEqual(1, len(topics))
 
545
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
 
546
            self.assertEqual(demo_module, topics[0].module)
 
547
        finally:
 
548
            del sys.modules['bzrlib.plugins.demo_module']
 
549
 
 
550
    def test_get_topics_no_topic(self):
 
551
        """Searching for something that is not a plugin returns []."""
 
552
        # test this by using a name that cannot be a plugin - its not
 
553
        # a valid python identifier.
 
554
        index = plugin.PluginsHelpIndex()
 
555
        self.assertEqual([], index.get_topics('nothing by this name'))
 
556
 
 
557
    def test_prefix(self):
 
558
        """PluginsHelpIndex has a prefix of 'plugins/'."""
 
559
        index = plugin.PluginsHelpIndex()
 
560
        self.assertEqual('plugins/', index.prefix)
 
561
 
 
562
    def test_get_plugin_topic_with_prefix(self):
 
563
        """Searching for plugins/demo_module returns help."""
 
564
        index = plugin.PluginsHelpIndex()
 
565
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
 
566
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
 
567
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
568
        try:
 
569
            topics = index.get_topics('plugins/demo_module')
 
570
            self.assertEqual(1, len(topics))
 
571
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
 
572
            self.assertEqual(demo_module, topics[0].module)
 
573
        finally:
 
574
            del sys.modules['bzrlib.plugins.demo_module']
 
575
 
 
576
 
 
577
class FakeModule(object):
 
578
    """A fake module to test with."""
 
579
 
 
580
    def __init__(self, doc, name):
 
581
        self.__doc__ = doc
 
582
        self.__name__ = name
 
583
 
 
584
 
 
585
class TestModuleHelpTopic(tests.TestCase):
 
586
    """Tests for the ModuleHelpTopic class."""
 
587
 
 
588
    def test_contruct(self):
 
589
        """Construction takes the module to document."""
 
590
        mod = FakeModule('foo', 'foo')
 
591
        topic = plugin.ModuleHelpTopic(mod)
 
592
        self.assertEqual(mod, topic.module)
 
593
 
 
594
    def test_get_help_text_None(self):
 
595
        """A ModuleHelpTopic returns the docstring for get_help_text."""
 
596
        mod = FakeModule(None, 'demo')
 
597
        topic = plugin.ModuleHelpTopic(mod)
 
598
        self.assertEqual("Plugin 'demo' has no docstring.\n",
 
599
            topic.get_help_text())
 
600
 
 
601
    def test_get_help_text_no_carriage_return(self):
 
602
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
 
603
        mod = FakeModule('one line of help', 'demo')
 
604
        topic = plugin.ModuleHelpTopic(mod)
 
605
        self.assertEqual("one line of help\n",
 
606
            topic.get_help_text())
 
607
 
 
608
    def test_get_help_text_carriage_return(self):
 
609
        """ModuleHelpTopic.get_help_text adds a \n if needed."""
 
610
        mod = FakeModule('two lines of help\nand more\n', 'demo')
 
611
        topic = plugin.ModuleHelpTopic(mod)
 
612
        self.assertEqual("two lines of help\nand more\n",
 
613
            topic.get_help_text())
 
614
 
 
615
    def test_get_help_text_with_additional_see_also(self):
 
616
        mod = FakeModule('two lines of help\nand more', 'demo')
 
617
        topic = plugin.ModuleHelpTopic(mod)
 
618
        self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
 
619
            topic.get_help_text(['foo', 'bar']))
 
620
 
 
621
    def test_get_help_topic(self):
 
622
        """The help topic for a plugin is its module name."""
 
623
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
 
624
        topic = plugin.ModuleHelpTopic(mod)
 
625
        self.assertEqual('demo', topic.get_help_topic())
 
626
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
 
627
        topic = plugin.ModuleHelpTopic(mod)
 
628
        self.assertEqual('foo_bar', topic.get_help_topic())
 
629
 
 
630
 
 
631
class TestLoadFromPath(tests.TestCaseInTempDir):
 
632
 
 
633
    def setUp(self):
 
634
        super(TestLoadFromPath, self).setUp()
 
635
        # Change bzrlib.plugin to think no plugins have been loaded yet.
 
636
        self.overrideAttr(bzrlib.plugins, '__path__', [])
 
637
        self.overrideAttr(plugin, '_loaded', False)
 
638
 
 
639
        # Monkey-patch load_from_path to stop it from actually loading anything.
 
640
        self.overrideAttr(plugin, 'load_from_path', lambda dirs: None)
 
641
 
 
642
    def test_set_plugins_path_with_args(self):
 
643
        plugin.set_plugins_path(['a', 'b'])
 
644
        self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
 
645
 
 
646
    def test_set_plugins_path_defaults(self):
 
647
        plugin.set_plugins_path()
 
648
        self.assertEqual(plugin.get_standard_plugins_path(),
 
649
                         bzrlib.plugins.__path__)
 
650
 
 
651
    def test_get_standard_plugins_path(self):
 
652
        path = plugin.get_standard_plugins_path()
 
653
        for directory in path:
 
654
            self.assertNotContainsRe(directory, r'\\/$')
 
655
        try:
 
656
            from distutils.sysconfig import get_python_lib
 
657
        except ImportError:
 
658
            pass
 
659
        else:
 
660
            if sys.platform != 'win32':
 
661
                python_lib = get_python_lib()
 
662
                for directory in path:
 
663
                    if directory.startswith(python_lib):
 
664
                        break
 
665
                else:
 
666
                    self.fail('No path to global plugins')
 
667
 
 
668
    def test_get_standard_plugins_path_env(self):
 
669
        self.overrideEnv('BZR_PLUGIN_PATH', 'foo/')
 
670
        path = plugin.get_standard_plugins_path()
 
671
        for directory in path:
 
672
            self.assertNotContainsRe(directory, r'\\/$')
 
673
 
 
674
    def test_load_plugins(self):
 
675
        plugin.load_plugins(['.'])
 
676
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
 
677
        # subsequent loads are no-ops
 
678
        plugin.load_plugins(['foo'])
 
679
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
 
680
 
 
681
    def test_load_plugins_default(self):
 
682
        plugin.load_plugins()
 
683
        path = plugin.get_standard_plugins_path()
 
684
        self.assertEqual(path, bzrlib.plugins.__path__)
 
685
 
 
686
 
 
687
class TestEnvPluginPath(tests.TestCase):
 
688
 
 
689
    def setUp(self):
 
690
        super(TestEnvPluginPath, self).setUp()
 
691
        self.overrideAttr(plugin, 'DEFAULT_PLUGIN_PATH', None)
 
692
 
 
693
        self.user = plugin.get_user_plugin_path()
 
694
        self.site = plugin.get_site_plugin_path()
 
695
        self.core = plugin.get_core_plugin_path()
 
696
 
 
697
    def _list2paths(self, *args):
 
698
        paths = []
 
699
        for p in args:
 
700
            plugin._append_new_path(paths, p)
 
701
        return paths
 
702
 
 
703
    def _set_path(self, *args):
 
704
        path = os.pathsep.join(self._list2paths(*args))
 
705
        self.overrideEnv('BZR_PLUGIN_PATH', path)
 
706
 
 
707
    def check_path(self, expected_dirs, setting_dirs):
 
708
        if setting_dirs:
 
709
            self._set_path(*setting_dirs)
 
710
        actual = plugin.get_standard_plugins_path()
 
711
        self.assertEquals(self._list2paths(*expected_dirs), actual)
 
712
 
 
713
    def test_default(self):
 
714
        self.check_path([self.user, self.core, self.site],
 
715
                        None)
 
716
 
 
717
    def test_adhoc_policy(self):
 
718
        self.check_path([self.user, self.core, self.site],
 
719
                        ['+user', '+core', '+site'])
 
720
 
 
721
    def test_fallback_policy(self):
 
722
        self.check_path([self.core, self.site, self.user],
 
723
                        ['+core', '+site', '+user'])
 
724
 
 
725
    def test_override_policy(self):
 
726
        self.check_path([self.user, self.site, self.core],
 
727
                        ['+user', '+site', '+core'])
 
728
 
 
729
    def test_disable_user(self):
 
730
        self.check_path([self.core, self.site], ['-user'])
 
731
 
 
732
    def test_disable_user_twice(self):
 
733
        # Ensures multiple removals don't left cruft
 
734
        self.check_path([self.core, self.site], ['-user', '-user'])
 
735
 
 
736
    def test_duplicates_are_removed(self):
 
737
        self.check_path([self.user, self.core, self.site],
 
738
                        ['+user', '+user'])
 
739
        # And only the first reference is kept (since the later references will
 
740
        # only produce '<plugin> already loaded' mutters)
 
741
        self.check_path([self.user, self.core, self.site],
 
742
                        ['+user', '+user', '+core',
 
743
                         '+user', '+site', '+site',
 
744
                         '+core'])
 
745
 
 
746
    def test_disable_overrides_enable(self):
 
747
        self.check_path([self.core, self.site], ['-user', '+user'])
 
748
 
 
749
    def test_disable_core(self):
 
750
        self.check_path([self.site], ['-core'])
 
751
        self.check_path([self.user, self.site], ['+user', '-core'])
 
752
 
 
753
    def test_disable_site(self):
 
754
        self.check_path([self.core], ['-site'])
 
755
        self.check_path([self.user, self.core], ['-site', '+user'])
 
756
 
 
757
    def test_override_site(self):
 
758
        self.check_path(['mysite', self.user, self.core],
 
759
                        ['mysite', '-site', '+user'])
 
760
        self.check_path(['mysite', self.core],
 
761
                        ['mysite', '-site'])
 
762
 
 
763
    def test_override_core(self):
 
764
        self.check_path(['mycore', self.user, self.site],
 
765
                        ['mycore', '-core', '+user', '+site'])
 
766
        self.check_path(['mycore', self.site],
 
767
                        ['mycore', '-core'])
 
768
 
 
769
    def test_my_plugin_only(self):
 
770
        self.check_path(['myplugin'], ['myplugin', '-user', '-core', '-site'])
 
771
 
 
772
    def test_my_plugin_first(self):
 
773
        self.check_path(['myplugin', self.core, self.site, self.user],
 
774
                        ['myplugin', '+core', '+site', '+user'])
 
775
 
 
776
    def test_bogus_references(self):
 
777
        self.check_path(['+foo', '-bar', self.core, self.site],
 
778
                        ['+foo', '-bar'])
 
779
 
 
780
 
 
781
class TestDisablePlugin(BaseTestPlugins):
 
782
 
 
783
    def setUp(self):
 
784
        super(TestDisablePlugin, self).setUp()
 
785
        self.create_plugin_package('test_foo')
 
786
        # Make sure we don't pollute the plugins namespace
 
787
        self.overrideAttr(plugins, '__path__')
 
788
        # Be paranoid in case a test fail
 
789
        self.addCleanup(self._unregister_plugin, 'test_foo')
 
790
 
 
791
    def test_cannot_import(self):
 
792
        self.overrideEnv('BZR_DISABLE_PLUGINS', 'test_foo')
 
793
        plugin.set_plugins_path(['.'])
 
794
        try:
 
795
            import bzrlib.plugins.test_foo
 
796
        except ImportError:
 
797
            pass
 
798
        self.assertPluginUnknown('test_foo')
 
799
 
 
800
    def test_regular_load(self):
 
801
        self.overrideAttr(plugin, '_loaded', False)
 
802
        plugin.load_plugins(['.'])
 
803
        self.assertPluginKnown('test_foo')
 
804
        self.assertDocstring("This is the doc for test_foo",
 
805
                             bzrlib.plugins.test_foo)
 
806
 
 
807
    def test_not_loaded(self):
 
808
        self.warnings = []
 
809
        def captured_warning(*args, **kwargs):
 
810
            self.warnings.append((args, kwargs))
 
811
        self.overrideAttr(trace, 'warning', captured_warning)
 
812
        # Reset the flag that protect against double loading
 
813
        self.overrideAttr(plugin, '_loaded', False)
 
814
        self.overrideEnv('BZR_DISABLE_PLUGINS', 'test_foo')
 
815
        plugin.load_plugins(['.'])
 
816
        self.assertPluginUnknown('test_foo')
 
817
        # Make sure we don't warn about the plugin ImportError since this has
 
818
        # been *requested* by the user.
 
819
        self.assertLength(0, self.warnings)
 
820
 
 
821
 
 
822
 
 
823
class TestLoadPluginAtSyntax(tests.TestCase):
 
824
 
 
825
    def _get_paths(self, paths):
 
826
        return plugin._get_specific_plugin_paths(paths)
 
827
 
 
828
    def test_empty(self):
 
829
        self.assertEquals([], self._get_paths(None))
 
830
        self.assertEquals([], self._get_paths(''))
 
831
 
 
832
    def test_one_path(self):
 
833
        self.assertEquals([('b', 'man')], self._get_paths('b@man'))
 
834
 
 
835
    def test_bogus_path(self):
 
836
        # We need a '@'
 
837
        self.assertRaises(errors.BzrCommandError, self._get_paths, 'batman')
 
838
        # Too much '@' isn't good either
 
839
        self.assertRaises(errors.BzrCommandError, self._get_paths,
 
840
                          'batman@mobile@cave')
 
841
        # An empty description probably indicates a problem
 
842
        self.assertRaises(errors.BzrCommandError, self._get_paths,
 
843
                          os.pathsep.join(['batman@cave', '', 'robin@mobile']))
 
844
 
 
845
 
 
846
class TestLoadPluginAt(BaseTestPlugins):
 
847
 
 
848
    def setUp(self):
 
849
        super(TestLoadPluginAt, self).setUp()
 
850
        # Make sure we don't pollute the plugins namespace
 
851
        self.overrideAttr(plugins, '__path__')
 
852
        # Reset the flag that protect against double loading
 
853
        self.overrideAttr(plugin, '_loaded', False)
 
854
        # Create the same plugin in two directories
 
855
        self.create_plugin_package('test_foo', dir='non-standard-dir')
 
856
        # The "normal" directory, we use 'standard' instead of 'plugins' to
 
857
        # avoid depending on the precise naming.
 
858
        self.create_plugin_package('test_foo', dir='standard/test_foo')
 
859
        # All the tests will load the 'test_foo' plugin from various locations
 
860
        self.addCleanup(self._unregister_plugin, 'test_foo')
 
861
        # Unfortunately there's global cached state for the specific
 
862
        # registered paths.
 
863
        self.addCleanup(plugin.PluginImporter.reset)
 
864
 
 
865
    def assertTestFooLoadedFrom(self, path):
 
866
        self.assertPluginKnown('test_foo')
 
867
        self.assertDocstring('This is the doc for test_foo',
 
868
                             bzrlib.plugins.test_foo)
 
869
        self.assertEqual(path, bzrlib.plugins.test_foo.dir_source)
 
870
 
 
871
    def test_regular_load(self):
 
872
        plugin.load_plugins(['standard'])
 
873
        self.assertTestFooLoadedFrom('standard/test_foo')
 
874
 
 
875
    def test_import(self):
 
876
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
877
        plugin.set_plugins_path(['standard'])
 
878
        try:
 
879
            import bzrlib.plugins.test_foo
 
880
        except ImportError:
 
881
            pass
 
882
        self.assertTestFooLoadedFrom('non-standard-dir')
 
883
 
 
884
    def test_loading(self):
 
885
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
886
        plugin.load_plugins(['standard'])
 
887
        self.assertTestFooLoadedFrom('non-standard-dir')
 
888
 
 
889
    def test_compiled_loaded(self):
 
890
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
891
        plugin.load_plugins(['standard'])
 
892
        self.assertTestFooLoadedFrom('non-standard-dir')
 
893
        self.assertIsSameRealPath('non-standard-dir/__init__.py',
 
894
                                  bzrlib.plugins.test_foo.__file__)
 
895
 
 
896
        # Try importing again now that the source has been compiled
 
897
        self._unregister_plugin('test_foo')
 
898
        plugin._loaded = False
 
899
        plugin.load_plugins(['standard'])
 
900
        self.assertTestFooLoadedFrom('non-standard-dir')
 
901
        if __debug__:
 
902
            suffix = 'pyc'
 
903
        else:
 
904
            suffix = 'pyo'
 
905
        self.assertIsSameRealPath('non-standard-dir/__init__.%s' % suffix,
 
906
                                  bzrlib.plugins.test_foo.__file__)
 
907
 
 
908
    def test_submodule_loading(self):
 
909
        # We create an additional directory under the one for test_foo
 
910
        self.create_plugin_package('test_bar', dir='non-standard-dir/test_bar')
 
911
        self.addCleanup(self._unregister_plugin_submodule,
 
912
                        'test_foo', 'test_bar')
 
913
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
914
        plugin.set_plugins_path(['standard'])
 
915
        import bzrlib.plugins.test_foo
 
916
        self.assertEqual('bzrlib.plugins.test_foo',
 
917
                         bzrlib.plugins.test_foo.__package__)
 
918
        import bzrlib.plugins.test_foo.test_bar
 
919
        self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
 
920
                                  bzrlib.plugins.test_foo.test_bar.__file__)
 
921
 
 
922
    def test_relative_submodule_loading(self):
 
923
        self.create_plugin_package('test_foo', dir='another-dir', source='''
 
924
import test_bar
 
925
''')
 
926
        # We create an additional directory under the one for test_foo
 
927
        self.create_plugin_package('test_bar', dir='another-dir/test_bar')
 
928
        self.addCleanup(self._unregister_plugin_submodule,
 
929
                        'test_foo', 'test_bar')
 
930
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@another-dir')
 
931
        plugin.set_plugins_path(['standard'])
 
932
        import bzrlib.plugins.test_foo
 
933
        self.assertEqual('bzrlib.plugins.test_foo',
 
934
                         bzrlib.plugins.test_foo.__package__)
 
935
        self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
 
936
                                  bzrlib.plugins.test_foo.test_bar.__file__)
 
937
 
 
938
    def test_loading_from___init__only(self):
 
939
        # We rename the existing __init__.py file to ensure that we don't load
 
940
        # a random file
 
941
        init = 'non-standard-dir/__init__.py'
 
942
        random = 'non-standard-dir/setup.py'
 
943
        os.rename(init, random)
 
944
        self.addCleanup(os.rename, random, init)
 
945
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
946
        plugin.load_plugins(['standard'])
 
947
        self.assertPluginUnknown('test_foo')
 
948
 
 
949
    def test_loading_from_specific_file(self):
 
950
        plugin_dir = 'non-standard-dir'
 
951
        plugin_file_name = 'iamtestfoo.py'
 
952
        plugin_path = osutils.pathjoin(plugin_dir, plugin_file_name)
 
953
        source = '''\
 
954
"""This is the doc for %s"""
 
955
dir_source = '%s'
 
956
''' % ('test_foo', plugin_path)
 
957
        self.create_plugin('test_foo', source=source,
 
958
                           dir=plugin_dir, file_name=plugin_file_name)
 
959
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@%s' % plugin_path)
 
960
        plugin.load_plugins(['standard'])
 
961
        self.assertTestFooLoadedFrom(plugin_path)
 
962
 
 
963
 
 
964
class TestDescribePlugins(BaseTestPlugins):
 
965
 
 
966
    def test_describe_plugins(self):
 
967
        class DummyModule(object):
 
968
            __doc__ = 'Hi there'
 
969
        class DummyPlugin(object):
 
970
            __version__ = '0.1.0'
 
971
            module = DummyModule()
 
972
        def dummy_plugins():
 
973
            return { 'good': DummyPlugin() }
 
974
        self.overrideAttr(plugin, 'plugin_warnings',
 
975
            {'bad': ['Failed to load (just testing)']})
 
976
        self.overrideAttr(plugin, 'plugins', dummy_plugins)
 
977
        self.assertEquals("""\
 
978
bad (failed to load)
 
979
  ** Failed to load (just testing)
 
980
 
 
981
good 0.1.0
 
982
  Hi there
 
983
 
 
984
""", ''.join(plugin.describe_plugins()))