← 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: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
1
 
# Copyright (C) 2005, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-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
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for plugins"""
18
18
 
20
20
# affects the global state of the process.  See bzrlib/plugins.py for more
21
21
# comments.
22
22
 
 
23
from cStringIO import StringIO
23
24
import logging
24
25
import os
25
 
from StringIO import StringIO
26
26
import sys
27
 
import zipfile
28
27
 
29
 
from bzrlib import plugin, tests
30
 
import bzrlib.plugin
31
 
import bzrlib.plugins
32
 
import bzrlib.commands
33
 
import bzrlib.help
34
 
from bzrlib.symbol_versioning import one_three
35
 
from bzrlib.tests import (
36
 
    TestCase,
37
 
    TestCaseInTempDir,
38
 
    TestUtil,
 
28
import bzrlib
 
29
from bzrlib import (
 
30
    osutils,
 
31
    plugin,
 
32
    plugins,
 
33
    tests,
 
34
    trace,
39
35
    )
40
 
from bzrlib.osutils import pathjoin, abspath, normpath
41
 
 
42
 
 
43
 
PLUGIN_TEXT = """\
44
 
import bzrlib.commands
45
 
class cmd_myplug(bzrlib.commands.Command):
46
 
    '''Just a simple test plugin.'''
47
 
    aliases = ['mplg']
48
 
    def run(self):
49
 
        print 'Hello from my plugin'
50
 
"""
 
36
 
51
37
 
52
38
# TODO: Write a test for plugin decoration of commands.
53
39
 
54
 
class TestLoadingPlugins(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):
55
92
 
56
93
    activeattributes = {}
57
94
 
65
102
        # set a place for the plugins to record their loading, and at the same
66
103
        # time validate that the location the plugins should record to is
67
104
        # valid and correct.
68
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
69
 
            [tempattribute] = []
 
105
        self.__class__.activeattributes [tempattribute] = []
70
106
        self.failUnless(tempattribute in self.activeattributes)
71
107
        # create two plugin directories
72
108
        os.mkdir('first')
73
109
        os.mkdir('second')
74
 
        # write a plugin that will record when its loaded in the 
 
110
        # write a plugin that will record when its loaded in the
75
111
        # tempattribute list.
76
112
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
77
113
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
96
132
        finally:
97
133
            # remove the plugin 'plugin'
98
134
            del self.activeattributes[tempattribute]
99
 
            if 'bzrlib.plugins.plugin' in sys.modules:
100
 
                del sys.modules['bzrlib.plugins.plugin']
101
 
            if getattr(bzrlib.plugins, 'plugin', None):
102
 
                del bzrlib.plugins.plugin
103
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
135
            self._unregister_plugin('plugin')
 
136
        self.assertPluginUnknown('plugin')
104
137
 
105
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)
106
141
        # This test tests that having two plugins in different
107
142
        # directories with different names allows them both to be loaded, when
108
143
        # we do a direct import statement.
119
154
        # create two plugin directories
120
155
        os.mkdir('first')
121
156
        os.mkdir('second')
122
 
        # write plugins that will record when they are loaded in the 
 
157
        # write plugins that will record when they are loaded in the
123
158
        # tempattribute list.
124
159
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
125
160
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
140
175
 
141
176
        oldpath = bzrlib.plugins.__path__
142
177
        try:
 
178
            self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
179
            self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
143
180
            bzrlib.plugins.__path__ = ['first', 'second']
144
181
            exec "import bzrlib.plugins.pluginone"
145
182
            self.assertEqual(['first'], self.activeattributes[tempattribute])
149
186
        finally:
150
187
            # remove the plugin 'plugin'
151
188
            del self.activeattributes[tempattribute]
152
 
            if getattr(bzrlib.plugins, 'pluginone', None):
153
 
                del bzrlib.plugins.pluginone
154
 
            if getattr(bzrlib.plugins, 'plugintwo', None):
155
 
                del bzrlib.plugins.plugintwo
156
 
        self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
157
 
        self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
 
189
            self._unregister_plugin('pluginone')
 
190
            self._unregister_plugin('plugintwo')
 
191
        self.assertPluginUnknown('pluginone')
 
192
        self.assertPluginUnknown('plugintwo')
158
193
 
159
194
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
160
195
        # This test tests that a plugin can load from a directory when the
161
196
        # directory in the path has a trailing slash.
162
197
        # check the plugin is not loaded already
163
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
198
        self.assertPluginUnknown('ts_plugin')
164
199
        tempattribute = "trailing-slash"
165
200
        self.failIf(tempattribute in self.activeattributes)
166
201
        # set a place for the plugin to record its loading, and at the same
171
206
        self.failUnless(tempattribute in self.activeattributes)
172
207
        # create a directory for the plugin
173
208
        os.mkdir('plugin_test')
174
 
        # write a plugin that will record when its loaded in the 
 
209
        # write a plugin that will record when its loaded in the
175
210
        # tempattribute list.
176
211
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
177
212
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
187
222
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
188
223
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
189
224
        finally:
190
 
            # remove the plugin 'plugin'
191
225
            del self.activeattributes[tempattribute]
192
 
            if getattr(bzrlib.plugins, 'ts_plugin', None):
193
 
                del bzrlib.plugins.ts_plugin
194
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
195
 
 
196
 
    def test_plugin_with_bad_name_does_not_load(self):
197
 
        # Create badly-named plugin
198
 
        file('bzr-bad plugin-name..py', 'w').close()
199
 
 
 
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
        """
200
235
        # Capture output
201
236
        stream = StringIO()
202
 
        handler = logging.StreamHandler(stream)
203
 
        log = logging.getLogger('bzr')
204
 
        log.addHandler(handler)
205
 
 
206
 
        bzrlib.plugin.load_from_dir('.')
207
 
 
208
 
        # Stop capturing output
209
 
        handler.flush()
210
 
        handler.close()
211
 
        log.removeHandler(handler)
212
 
 
213
 
        self.assertContainsRe(stream.getvalue(),
 
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,
214
279
            r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
215
280
            "because the file path isn't a valid module name; try renaming "
216
281
            "it to 'bad_plugin_name_'\.")
217
282
 
218
 
        stream.close()
219
 
 
220
 
 
221
 
class TestPlugins(TestCaseInTempDir):
 
283
 
 
284
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
222
285
 
223
286
    def setup_plugin(self, source=""):
224
287
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
225
288
        # check the plugin is not loaded already
226
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
289
        self.assertPluginUnknown('plugin')
227
290
        # write a plugin that _cannot_ fail to load.
228
291
        file('plugin.py', 'w').write(source + '\n')
229
292
        self.addCleanup(self.teardown_plugin)
230
 
        bzrlib.plugin.load_from_path(['.'])
231
 
    
 
293
        plugin.load_from_path(['.'])
 
294
 
232
295
    def teardown_plugin(self):
233
 
        # remove the plugin 'plugin'
234
 
        if 'bzrlib.plugins.plugin' in sys.modules:
235
 
            del sys.modules['bzrlib.plugins.plugin']
236
 
        if getattr(bzrlib.plugins, 'plugin', None):
237
 
            del bzrlib.plugins.plugin
238
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
296
        self._unregister_plugin('plugin')
 
297
        self.assertPluginUnknown('plugin')
239
298
 
240
299
    def test_plugin_appears_in_plugins(self):
241
300
        self.setup_plugin()
242
 
        self.failUnless('plugin' in bzrlib.plugin.plugins())
243
 
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
244
 
        plugins = bzrlib.plugin.plugins()
245
 
        plugin = plugins['plugin']
246
 
        self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
247
 
        self.assertEqual(bzrlib.plugins.plugin, plugin.module)
 
301
        self.assertPluginKnown('plugin')
 
302
        p = plugin.plugins()['plugin']
 
303
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
 
304
        self.assertEqual(p.module, plugins.plugin)
248
305
 
249
306
    def test_trivial_plugin_get_path(self):
250
307
        self.setup_plugin()
251
 
        plugins = bzrlib.plugin.plugins()
252
 
        plugin = plugins['plugin']
 
308
        p = plugin.plugins()['plugin']
253
309
        plugin_path = self.test_dir + '/plugin.py'
254
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
310
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
255
311
 
256
312
    def test_plugin_get_path_py_not_pyc(self):
257
 
        self.setup_plugin()         # after first import there will be plugin.pyc
 
313
        # first import creates plugin.pyc
 
314
        self.setup_plugin()
258
315
        self.teardown_plugin()
259
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
260
 
        plugins = bzrlib.plugin.plugins()
261
 
        plugin = plugins['plugin']
 
316
        plugin.load_from_path(['.']) # import plugin.pyc
 
317
        p = plugin.plugins()['plugin']
262
318
        plugin_path = self.test_dir + '/plugin.py'
263
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
319
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
264
320
 
265
321
    def test_plugin_get_path_pyc_only(self):
266
 
        self.setup_plugin()         # after first import there will be plugin.pyc
 
322
        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)
 
323
        self.setup_plugin()
267
324
        self.teardown_plugin()
268
325
        os.unlink(self.test_dir + '/plugin.py')
269
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
270
 
        plugins = bzrlib.plugin.plugins()
271
 
        plugin = plugins['plugin']
 
326
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
327
        p = plugin.plugins()['plugin']
272
328
        if __debug__:
273
329
            plugin_path = self.test_dir + '/plugin.pyc'
274
330
        else:
275
331
            plugin_path = self.test_dir + '/plugin.pyo'
276
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
332
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
277
333
 
278
334
    def test_no_test_suite_gives_None_for_test_suite(self):
279
335
        self.setup_plugin()
280
 
        plugin = bzrlib.plugin.plugins()['plugin']
281
 
        self.assertEqual(None, plugin.test_suite())
 
336
        p = plugin.plugins()['plugin']
 
337
        self.assertEqual(None, p.test_suite())
282
338
 
283
339
    def test_test_suite_gives_test_suite_result(self):
284
340
        source = """def test_suite(): return 'foo'"""
285
341
        self.setup_plugin(source)
286
 
        plugin = bzrlib.plugin.plugins()['plugin']
287
 
        self.assertEqual('foo', plugin.test_suite())
 
342
        p = plugin.plugins()['plugin']
 
343
        self.assertEqual('foo', p.test_suite())
288
344
 
289
345
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
290
346
        self.setup_plugin()
291
 
        loader = TestUtil.TestLoader()
292
 
        plugin = bzrlib.plugin.plugins()['plugin']
293
 
        self.assertEqual(None, plugin.load_plugin_tests(loader))
 
347
        loader = tests.TestUtil.TestLoader()
 
348
        p = plugin.plugins()['plugin']
 
349
        self.assertEqual(None, p.load_plugin_tests(loader))
294
350
 
295
351
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
296
352
        source = """
297
353
def load_tests(standard_tests, module, loader):
298
354
    return 'foo'"""
299
355
        self.setup_plugin(source)
300
 
        loader = TestUtil.TestLoader()
301
 
        plugin = bzrlib.plugin.plugins()['plugin']
302
 
        self.assertEqual('foo', plugin.load_plugin_tests(loader))
 
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())
303
363
 
304
364
    def test_no_version_info(self):
305
 
        self.setup_plugin()
306
 
        plugin = bzrlib.plugin.plugins()['plugin']
307
 
        self.assertEqual(None, plugin.version_info())
 
365
        self.check_version_info(None)
308
366
 
309
367
    def test_with_version_info(self):
310
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
311
 
        plugin = bzrlib.plugin.plugins()['plugin']
312
 
        self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
 
368
        self.check_version_info((1, 2, 3, 'dev', 4),
 
369
                                "version_info = (1, 2, 3, 'dev', 4)")
313
370
 
314
371
    def test_short_version_info_gets_padded(self):
315
372
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
316
373
        # so we adapt it
317
 
        self.setup_plugin("version_info = (1, 2, 3)")
318
 
        plugin = bzrlib.plugin.plugins()['plugin']
319
 
        self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
 
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__)
320
380
 
321
381
    def test_no_version_info___version__(self):
322
382
        self.setup_plugin()
323
383
        plugin = bzrlib.plugin.plugins()['plugin']
324
384
        self.assertEqual("unknown", plugin.__version__)
325
385
 
326
 
    def test___version__with_version_info(self):
 
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):
327
422
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
328
423
        plugin = bzrlib.plugin.plugins()['plugin']
329
424
        self.assertEqual("1.2.3dev4", plugin.__version__)
330
425
 
331
426
    def test_final__version__with_version_info(self):
332
 
        self.setup_plugin("version_info = (1, 2, 3, 'final', 4)")
 
427
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
333
428
        plugin = bzrlib.plugin.plugins()['plugin']
334
429
        self.assertEqual("1.2.3", plugin.__version__)
335
430
 
336
 
 
337
 
class TestPluginHelp(TestCaseInTempDir):
 
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):
338
438
 
339
439
    def split_help_commands(self):
340
440
        help = {}
341
441
        current = None
342
 
        for line in self.run_bzr('help commands')[0].splitlines():
 
442
        out, err = self.run_bzr('--no-plugins help commands')
 
443
        for line in out.splitlines():
343
444
            if not line.startswith(' '):
344
445
                current = line.split()[0]
345
446
            help[current] = help.get(current, '') + line
368
469
    def test_plugin_help_shows_plugin(self):
369
470
        # Create a test plugin
370
471
        os.mkdir('plugin_test')
371
 
        f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
372
 
        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
    '''Just a simple test plugin.'''
 
477
    aliases = ['mplg']
 
478
    def run(self):
 
479
        print 'Hello from my plugin'
 
480
 
 
481
"""
 
482
)
373
483
        f.close()
374
484
 
375
485
        try:
382
492
            self.assertContainsRe(help, '\[myplug\]')
383
493
        finally:
384
494
            # unregister command
385
 
            if bzrlib.commands.plugin_cmds.get('myplug', None):
386
 
                del bzrlib.commands.plugin_cmds['myplug']
 
495
            if 'myplug' in bzrlib.commands.plugin_cmds:
 
496
                bzrlib.commands.plugin_cmds.remove('myplug')
387
497
            # remove the plugin 'myplug'
388
498
            if getattr(bzrlib.plugins, 'myplug', None):
389
499
                delattr(bzrlib.plugins, 'myplug')
390
500
 
391
501
 
392
 
class TestPluginFromZip(TestCaseInTempDir):
393
 
 
394
 
    def make_zipped_plugin(self, zip_name, filename):
395
 
        z = zipfile.ZipFile(zip_name, 'w')
396
 
        z.writestr(filename, PLUGIN_TEXT)
397
 
        z.close()
398
 
 
399
 
    def check_plugin_load(self, zip_name, plugin_name):
400
 
        self.assertFalse(plugin_name in dir(bzrlib.plugins),
401
 
                         'Plugin already loaded')
402
 
        old_path = bzrlib.plugins.__path__
403
 
        try:
404
 
            # this is normally done by load_plugins -> set_plugins_path
405
 
            bzrlib.plugins.__path__ = [zip_name]
406
 
            self.applyDeprecated(one_three,
407
 
                bzrlib.plugin.load_from_zip, zip_name)
408
 
            self.assertTrue(plugin_name in dir(bzrlib.plugins),
409
 
                            'Plugin is not loaded')
410
 
        finally:
411
 
            # unregister plugin
412
 
            if getattr(bzrlib.plugins, plugin_name, None):
413
 
                delattr(bzrlib.plugins, plugin_name)
414
 
                del sys.modules['bzrlib.plugins.' + plugin_name]
415
 
            bzrlib.plugins.__path__ = old_path
416
 
 
417
 
    def test_load_module(self):
418
 
        self.make_zipped_plugin('./test.zip', 'ziplug.py')
419
 
        self.check_plugin_load('./test.zip', 'ziplug')
420
 
 
421
 
    def test_load_package(self):
422
 
        self.make_zipped_plugin('./test.zip', 'ziplug/__init__.py')
423
 
        self.check_plugin_load('./test.zip', 'ziplug')
424
 
 
425
 
 
426
 
class TestSetPluginsPath(TestCase):
427
 
    
428
 
    def test_set_plugins_path(self):
429
 
        """set_plugins_path should set the module __path__ correctly."""
430
 
        old_path = bzrlib.plugins.__path__
431
 
        try:
432
 
            bzrlib.plugins.__path__ = []
433
 
            expected_path = bzrlib.plugin.set_plugins_path()
434
 
            self.assertEqual(expected_path, bzrlib.plugins.__path__)
435
 
        finally:
436
 
            bzrlib.plugins.__path__ = old_path
437
 
 
438
 
    def test_set_plugins_path_with_trailing_slashes(self):
439
 
        """set_plugins_path should set the module __path__ based on
440
 
        BZR_PLUGIN_PATH."""
441
 
        old_path = bzrlib.plugins.__path__
442
 
        old_env = os.environ.get('BZR_PLUGIN_PATH')
443
 
        try:
444
 
            bzrlib.plugins.__path__ = []
445
 
            os.environ['BZR_PLUGIN_PATH'] = "first\\//\\" + os.pathsep + \
446
 
                "second/\\/\\/"
447
 
            bzrlib.plugin.set_plugins_path()
448
 
            expected_path = ['first', 'second',
449
 
                os.path.dirname(bzrlib.plugins.__file__)]
450
 
            self.assertEqual(expected_path,
451
 
                bzrlib.plugins.__path__[:len(expected_path)])
452
 
        finally:
453
 
            bzrlib.plugins.__path__ = old_path
454
 
            if old_env is not None:
455
 
                os.environ['BZR_PLUGIN_PATH'] = old_env
456
 
            else:
457
 
                del os.environ['BZR_PLUGIN_PATH']
458
 
 
459
 
 
460
502
class TestHelpIndex(tests.TestCase):
461
503
    """Tests for the PluginsHelpIndex class."""
462
504
 
563
605
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
564
606
        topic = plugin.ModuleHelpTopic(mod)
565
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.assertEqual("This is the doc for test_foo",
 
784
                         bzrlib.plugins.test_foo.__doc__)
 
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.assertEqual('This is the doc for test_foo',
 
820
                         bzrlib.plugins.test_foo.__doc__)
 
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)