/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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