← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_plugins.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

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-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
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.tests import (
35
 
    TestCase,
36
 
    TestCaseInTempDir,
37
 
    TestUtil,
 
28
import bzrlib
 
29
from bzrlib import (
 
30
    errors,
 
31
    osutils,
 
32
    plugin,
 
33
    plugins,
 
34
    tests,
 
35
    trace,
38
36
    )
39
 
from bzrlib.osutils import pathjoin, abspath, normpath
40
 
 
41
 
 
42
 
PLUGIN_TEXT = """\
43
 
import bzrlib.commands
44
 
class cmd_myplug(bzrlib.commands.Command):
45
 
    '''Just a simple test plugin.'''
46
 
    aliases = ['mplg']
47
 
    def run(self):
48
 
        print 'Hello from my plugin'
49
 
"""
 
37
 
50
38
 
51
39
# TODO: Write a test for plugin decoration of commands.
52
40
 
53
 
class TestLoadingPlugins(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.assertFalse(getattr(bzrlib.plugins, name, None) is not None)
 
95
        self.assertFalse('bzrlib.plugins.%s' % name in sys.modules)
 
96
 
 
97
    def assertPluginKnown(self, name):
 
98
        self.assertTrue(getattr(bzrlib.plugins, name, None) is not None)
 
99
        self.assertTrue('bzrlib.plugins.%s' % name in sys.modules)
 
100
 
 
101
 
 
102
class TestLoadingPlugins(BaseTestPlugins):
54
103
 
55
104
    activeattributes = {}
56
105
 
60
109
        # file name we can use which is also a valid attribute for accessing in
61
110
        # activeattributes. - we cannot give import parameters.
62
111
        tempattribute = "0"
63
 
        self.failIf(tempattribute in self.activeattributes)
 
112
        self.assertFalse(tempattribute in self.activeattributes)
64
113
        # set a place for the plugins to record their loading, and at the same
65
114
        # time validate that the location the plugins should record to is
66
115
        # valid and correct.
67
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
68
 
            [tempattribute] = []
69
 
        self.failUnless(tempattribute in self.activeattributes)
 
116
        self.__class__.activeattributes [tempattribute] = []
 
117
        self.assertTrue(tempattribute in self.activeattributes)
70
118
        # create two plugin directories
71
119
        os.mkdir('first')
72
120
        os.mkdir('second')
95
143
        finally:
96
144
            # remove the plugin 'plugin'
97
145
            del self.activeattributes[tempattribute]
98
 
            if 'bzrlib.plugins.plugin' in sys.modules:
99
 
                del sys.modules['bzrlib.plugins.plugin']
100
 
            if getattr(bzrlib.plugins, 'plugin', None):
101
 
                del bzrlib.plugins.plugin
102
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
146
            self._unregister_plugin('plugin')
 
147
        self.assertPluginUnknown('plugin')
103
148
 
104
149
    def test_plugins_from_different_dirs_can_demand_load(self):
 
150
        self.assertFalse('bzrlib.plugins.pluginone' in sys.modules)
 
151
        self.assertFalse('bzrlib.plugins.plugintwo' in sys.modules)
105
152
        # This test tests that having two plugins in different
106
153
        # directories with different names allows them both to be loaded, when
107
154
        # we do a direct import statement.
108
155
        # Determine a file name we can use which is also a valid attribute
109
156
        # for accessing in activeattributes. - we cannot give import parameters.
110
157
        tempattribute = "different-dirs"
111
 
        self.failIf(tempattribute in self.activeattributes)
 
158
        self.assertFalse(tempattribute in self.activeattributes)
112
159
        # set a place for the plugins to record their loading, and at the same
113
160
        # time validate that the location the plugins should record to is
114
161
        # valid and correct.
115
162
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
116
163
            [tempattribute] = []
117
 
        self.failUnless(tempattribute in self.activeattributes)
 
164
        self.assertTrue(tempattribute in self.activeattributes)
118
165
        # create two plugin directories
119
166
        os.mkdir('first')
120
167
        os.mkdir('second')
139
186
 
140
187
        oldpath = bzrlib.plugins.__path__
141
188
        try:
 
189
            self.assertFalse('bzrlib.plugins.pluginone' in sys.modules)
 
190
            self.assertFalse('bzrlib.plugins.plugintwo' in sys.modules)
142
191
            bzrlib.plugins.__path__ = ['first', 'second']
143
192
            exec "import bzrlib.plugins.pluginone"
144
193
            self.assertEqual(['first'], self.activeattributes[tempattribute])
148
197
        finally:
149
198
            # remove the plugin 'plugin'
150
199
            del self.activeattributes[tempattribute]
151
 
            if getattr(bzrlib.plugins, 'pluginone', None):
152
 
                del bzrlib.plugins.pluginone
153
 
            if getattr(bzrlib.plugins, 'plugintwo', None):
154
 
                del bzrlib.plugins.plugintwo
155
 
        self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
156
 
        self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
 
200
            self._unregister_plugin('pluginone')
 
201
            self._unregister_plugin('plugintwo')
 
202
        self.assertPluginUnknown('pluginone')
 
203
        self.assertPluginUnknown('plugintwo')
157
204
 
158
205
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
159
206
        # This test tests that a plugin can load from a directory when the
160
207
        # directory in the path has a trailing slash.
161
208
        # check the plugin is not loaded already
162
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
209
        self.assertPluginUnknown('ts_plugin')
163
210
        tempattribute = "trailing-slash"
164
 
        self.failIf(tempattribute in self.activeattributes)
 
211
        self.assertFalse(tempattribute in self.activeattributes)
165
212
        # set a place for the plugin to record its loading, and at the same
166
213
        # time validate that the location the plugin should record to is
167
214
        # valid and correct.
168
215
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
169
216
            [tempattribute] = []
170
 
        self.failUnless(tempattribute in self.activeattributes)
 
217
        self.assertTrue(tempattribute in self.activeattributes)
171
218
        # create a directory for the plugin
172
219
        os.mkdir('plugin_test')
173
220
        # write a plugin that will record when its loaded in the
186
233
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
187
234
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
188
235
        finally:
189
 
            # remove the plugin 'plugin'
190
236
            del self.activeattributes[tempattribute]
191
 
            if getattr(bzrlib.plugins, 'ts_plugin', None):
192
 
                del bzrlib.plugins.ts_plugin
193
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
237
            self._unregister_plugin('ts_plugin')
 
238
        self.assertPluginUnknown('ts_plugin')
194
239
 
195
240
    def load_and_capture(self, name):
196
241
        """Load plugins from '.' capturing the output.
222
267
            stream.close()
223
268
 
224
269
    def test_plugin_with_bad_api_version_reports(self):
225
 
        # This plugin asks for bzrlib api version 1.0.0, which is not supported
226
 
        # anymore.
 
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', {})
227
277
        name = 'wants100.py'
228
278
        f = file(name, 'w')
229
279
        try:
231
281
                "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
232
282
        finally:
233
283
            f.close()
234
 
 
235
284
        log = self.load_and_capture(name)
236
 
        self.assertContainsRe(log,
 
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],
237
292
            r"It requested API version")
238
293
 
239
294
    def test_plugin_with_bad_name_does_not_load(self):
247
302
            "it to 'bad_plugin_name_'\.")
248
303
 
249
304
 
250
 
class TestPlugins(TestCaseInTempDir):
 
305
class TestPlugins(BaseTestPlugins):
251
306
 
252
307
    def setup_plugin(self, source=""):
253
308
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
254
309
        # check the plugin is not loaded already
255
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
310
        self.assertPluginUnknown('plugin')
256
311
        # write a plugin that _cannot_ fail to load.
257
 
        file('plugin.py', 'w').write(source + '\n')
 
312
        with file('plugin.py', 'w') as f: f.write(source + '\n')
258
313
        self.addCleanup(self.teardown_plugin)
259
 
        bzrlib.plugin.load_from_path(['.'])
 
314
        plugin.load_from_path(['.'])
260
315
 
261
316
    def teardown_plugin(self):
262
 
        # remove the plugin 'plugin'
263
 
        if 'bzrlib.plugins.plugin' in sys.modules:
264
 
            del sys.modules['bzrlib.plugins.plugin']
265
 
        if getattr(bzrlib.plugins, 'plugin', None):
266
 
            del bzrlib.plugins.plugin
267
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
317
        self._unregister_plugin('plugin')
 
318
        self.assertPluginUnknown('plugin')
268
319
 
269
320
    def test_plugin_appears_in_plugins(self):
270
321
        self.setup_plugin()
271
 
        self.failUnless('plugin' in bzrlib.plugin.plugins())
272
 
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
273
 
        plugins = bzrlib.plugin.plugins()
274
 
        plugin = plugins['plugin']
275
 
        self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
276
 
        self.assertEqual(bzrlib.plugins.plugin, plugin.module)
 
322
        self.assertPluginKnown('plugin')
 
323
        p = plugin.plugins()['plugin']
 
324
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
 
325
        self.assertEqual(p.module, plugins.plugin)
277
326
 
278
327
    def test_trivial_plugin_get_path(self):
279
328
        self.setup_plugin()
280
 
        plugins = bzrlib.plugin.plugins()
281
 
        plugin = plugins['plugin']
 
329
        p = plugin.plugins()['plugin']
282
330
        plugin_path = self.test_dir + '/plugin.py'
283
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
331
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
284
332
 
285
333
    def test_plugin_get_path_py_not_pyc(self):
286
 
        self.setup_plugin()         # after first import there will be plugin.pyc
 
334
        # first import creates plugin.pyc
 
335
        self.setup_plugin()
287
336
        self.teardown_plugin()
288
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
289
 
        plugins = bzrlib.plugin.plugins()
290
 
        plugin = plugins['plugin']
 
337
        plugin.load_from_path(['.']) # import plugin.pyc
 
338
        p = plugin.plugins()['plugin']
291
339
        plugin_path = self.test_dir + '/plugin.py'
292
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
340
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
293
341
 
294
342
    def test_plugin_get_path_pyc_only(self):
295
 
        self.setup_plugin()         # after first import there will be plugin.pyc
 
343
        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)
 
344
        self.setup_plugin()
296
345
        self.teardown_plugin()
297
346
        os.unlink(self.test_dir + '/plugin.py')
298
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
299
 
        plugins = bzrlib.plugin.plugins()
300
 
        plugin = plugins['plugin']
 
347
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
348
        p = plugin.plugins()['plugin']
301
349
        if __debug__:
302
350
            plugin_path = self.test_dir + '/plugin.pyc'
303
351
        else:
304
352
            plugin_path = self.test_dir + '/plugin.pyo'
305
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
353
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
306
354
 
307
355
    def test_no_test_suite_gives_None_for_test_suite(self):
308
356
        self.setup_plugin()
309
 
        plugin = bzrlib.plugin.plugins()['plugin']
310
 
        self.assertEqual(None, plugin.test_suite())
 
357
        p = plugin.plugins()['plugin']
 
358
        self.assertEqual(None, p.test_suite())
311
359
 
312
360
    def test_test_suite_gives_test_suite_result(self):
313
361
        source = """def test_suite(): return 'foo'"""
314
362
        self.setup_plugin(source)
315
 
        plugin = bzrlib.plugin.plugins()['plugin']
316
 
        self.assertEqual('foo', plugin.test_suite())
 
363
        p = plugin.plugins()['plugin']
 
364
        self.assertEqual('foo', p.test_suite())
317
365
 
318
366
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
319
367
        self.setup_plugin()
320
 
        loader = TestUtil.TestLoader()
321
 
        plugin = bzrlib.plugin.plugins()['plugin']
322
 
        self.assertEqual(None, plugin.load_plugin_tests(loader))
 
368
        loader = tests.TestUtil.TestLoader()
 
369
        p = plugin.plugins()['plugin']
 
370
        self.assertEqual(None, p.load_plugin_tests(loader))
323
371
 
324
372
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
325
373
        source = """
326
374
def load_tests(standard_tests, module, loader):
327
375
    return 'foo'"""
328
376
        self.setup_plugin(source)
329
 
        loader = TestUtil.TestLoader()
330
 
        plugin = bzrlib.plugin.plugins()['plugin']
331
 
        self.assertEqual('foo', plugin.load_plugin_tests(loader))
 
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())
332
384
 
333
385
    def test_no_version_info(self):
334
 
        self.setup_plugin()
335
 
        plugin = bzrlib.plugin.plugins()['plugin']
336
 
        self.assertEqual(None, plugin.version_info())
 
386
        self.check_version_info(None)
337
387
 
338
388
    def test_with_version_info(self):
339
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
340
 
        plugin = bzrlib.plugin.plugins()['plugin']
341
 
        self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
 
389
        self.check_version_info((1, 2, 3, 'dev', 4),
 
390
                                "version_info = (1, 2, 3, 'dev', 4)")
342
391
 
343
392
    def test_short_version_info_gets_padded(self):
344
393
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
345
394
        # so we adapt it
346
 
        self.setup_plugin("version_info = (1, 2, 3)")
347
 
        plugin = bzrlib.plugin.plugins()['plugin']
348
 
        self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
 
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__)
349
401
 
350
402
    def test_no_version_info___version__(self):
351
403
        self.setup_plugin()
390
442
    def test_dev_fallback__version__with_version_info(self):
391
443
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
392
444
        plugin = bzrlib.plugin.plugins()['plugin']
393
 
        self.assertEqual("1.2.3.dev.4", plugin.__version__)
 
445
        self.assertEqual("1.2.3dev4", plugin.__version__)
394
446
 
395
447
    def test_final__version__with_version_info(self):
396
448
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
397
449
        plugin = bzrlib.plugin.plugins()['plugin']
398
450
        self.assertEqual("1.2.3", plugin.__version__)
399
451
 
400
 
 
401
 
class TestPluginHelp(TestCaseInTempDir):
 
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.2", plugin.__version__)
 
456
 
 
457
 
 
458
class TestPluginHelp(tests.TestCaseInTempDir):
402
459
 
403
460
    def split_help_commands(self):
404
461
        help = {}
433
490
    def test_plugin_help_shows_plugin(self):
434
491
        # Create a test plugin
435
492
        os.mkdir('plugin_test')
436
 
        f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
437
 
        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
)
438
504
        f.close()
439
505
 
440
506
        try:
454
520
                delattr(bzrlib.plugins, 'myplug')
455
521
 
456
522
 
457
 
class TestSetPluginsPath(TestCase):
458
 
 
459
 
    def test_set_plugins_path(self):
460
 
        """set_plugins_path should set the module __path__ correctly."""
461
 
        old_path = bzrlib.plugins.__path__
462
 
        try:
463
 
            bzrlib.plugins.__path__ = []
464
 
            expected_path = bzrlib.plugin.set_plugins_path()
465
 
            self.assertEqual(expected_path, bzrlib.plugins.__path__)
466
 
        finally:
467
 
            bzrlib.plugins.__path__ = old_path
468
 
 
469
 
    def test_set_plugins_path_with_trailing_slashes(self):
470
 
        """set_plugins_path should set the module __path__ based on
471
 
        BZR_PLUGIN_PATH after removing all trailing slashes."""
472
 
        old_path = bzrlib.plugins.__path__
473
 
        old_env = os.environ.get('BZR_PLUGIN_PATH')
474
 
        try:
475
 
            bzrlib.plugins.__path__ = []
476
 
            os.environ['BZR_PLUGIN_PATH'] = "first\\//\\" + os.pathsep + \
477
 
                "second/\\/\\/"
478
 
            bzrlib.plugin.set_plugins_path()
479
 
            # We expect our nominated paths to have all path-seps removed,
480
 
            # and this is testing only that.
481
 
            expected_path = ['first', 'second']
482
 
            self.assertEqual(expected_path,
483
 
                bzrlib.plugins.__path__[:len(expected_path)])
484
 
        finally:
485
 
            bzrlib.plugins.__path__ = old_path
486
 
            if old_env is not None:
487
 
                os.environ['BZR_PLUGIN_PATH'] = old_env
488
 
            else:
489
 
                del os.environ['BZR_PLUGIN_PATH']
490
 
 
491
 
 
492
523
class TestHelpIndex(tests.TestCase):
493
524
    """Tests for the PluginsHelpIndex class."""
494
525
 
584
615
    def test_get_help_text_with_additional_see_also(self):
585
616
        mod = FakeModule('two lines of help\nand more', 'demo')
586
617
        topic = plugin.ModuleHelpTopic(mod)
587
 
        self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
588
 
            topic.get_help_text(['foo', 'bar']))
 
618
        self.assertEqual("two lines of help\nand more\n\n:See also: bar, foo\n",
 
619
                         topic.get_help_text(['foo', 'bar']))
589
620
 
590
621
    def test_get_help_topic(self):
591
622
        """The help topic for a plugin is its module name."""
592
623
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
593
624
        topic = plugin.ModuleHelpTopic(mod)
594
625
        self.assertEqual('demo', topic.get_help_topic())
595
 
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
 
626
        mod = FakeModule('two lines of help\nand more',
 
627
                         'bzrlib.plugins.foo_bar')
596
628
        topic = plugin.ModuleHelpTopic(mod)
597
629
        self.assertEqual('foo_bar', topic.get_help_topic())
598
630
 
599
631
 
600
 
def clear_plugins(test_case):
601
 
    # Save the attributes that we're about to monkey-patch.
602
 
    old_plugins_path = bzrlib.plugins.__path__
603
 
    old_loaded = plugin._loaded
604
 
    old_load_from_path = plugin.load_from_path
605
 
    # Change bzrlib.plugin to think no plugins have been loaded yet.
606
 
    bzrlib.plugins.__path__ = []
607
 
    plugin._loaded = False
608
 
    # Monkey-patch load_from_path to stop it from actually loading anything.
609
 
    def load_from_path(dirs):
610
 
        pass
611
 
    plugin.load_from_path = load_from_path
612
 
    def restore_plugins():
613
 
        bzrlib.plugins.__path__ = old_plugins_path
614
 
        plugin._loaded = old_loaded
615
 
        plugin.load_from_path = old_load_from_path
616
 
    test_case.addCleanup(restore_plugins)
617
 
 
618
 
 
619
 
class TestPluginPaths(tests.TestCase):
 
632
class TestLoadFromPath(tests.TestCaseInTempDir):
 
633
 
 
634
    def setUp(self):
 
635
        super(TestLoadFromPath, self).setUp()
 
636
        # Change bzrlib.plugin to think no plugins have been loaded yet.
 
637
        self.overrideAttr(bzrlib.plugins, '__path__', [])
 
638
        self.overrideAttr(plugin, '_loaded', False)
 
639
 
 
640
        # Monkey-patch load_from_path to stop it from actually loading anything.
 
641
        self.overrideAttr(plugin, 'load_from_path', lambda dirs: None)
620
642
 
621
643
    def test_set_plugins_path_with_args(self):
622
 
        clear_plugins(self)
623
644
        plugin.set_plugins_path(['a', 'b'])
624
645
        self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
625
646
 
626
647
    def test_set_plugins_path_defaults(self):
627
 
        clear_plugins(self)
628
648
        plugin.set_plugins_path()
629
649
        self.assertEqual(plugin.get_standard_plugins_path(),
630
650
                         bzrlib.plugins.__path__)
631
651
 
632
652
    def test_get_standard_plugins_path(self):
633
653
        path = plugin.get_standard_plugins_path()
634
 
        self.assertEqual(plugin.get_default_plugin_path(), path[0])
635
654
        for directory in path:
636
655
            self.assertNotContainsRe(directory, r'\\/$')
637
656
        try:
648
667
                    self.fail('No path to global plugins')
649
668
 
650
669
    def test_get_standard_plugins_path_env(self):
651
 
        os.environ['BZR_PLUGIN_PATH'] = 'foo/'
652
 
        self.assertEqual('foo', plugin.get_standard_plugins_path()[0])
653
 
 
654
 
 
655
 
class TestLoadPlugins(tests.TestCaseInTempDir):
 
670
        self.overrideEnv('BZR_PLUGIN_PATH', 'foo/')
 
671
        path = plugin.get_standard_plugins_path()
 
672
        for directory in path:
 
673
            self.assertNotContainsRe(directory, r'\\/$')
656
674
 
657
675
    def test_load_plugins(self):
658
 
        clear_plugins(self)
659
676
        plugin.load_plugins(['.'])
660
677
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
661
678
        # subsequent loads are no-ops
663
680
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
664
681
 
665
682
    def test_load_plugins_default(self):
666
 
        clear_plugins(self)
667
683
        plugin.load_plugins()
668
684
        path = plugin.get_standard_plugins_path()
669
685
        self.assertEqual(path, bzrlib.plugins.__path__)
 
686
 
 
687
 
 
688
class TestEnvPluginPath(tests.TestCase):
 
689
 
 
690
    def setUp(self):
 
691
        super(TestEnvPluginPath, self).setUp()
 
692
        self.overrideAttr(plugin, 'DEFAULT_PLUGIN_PATH', None)
 
693
 
 
694
        self.user = plugin.get_user_plugin_path()
 
695
        self.site = plugin.get_site_plugin_path()
 
696
        self.core = plugin.get_core_plugin_path()
 
697
 
 
698
    def _list2paths(self, *args):
 
699
        paths = []
 
700
        for p in args:
 
701
            plugin._append_new_path(paths, p)
 
702
        return paths
 
703
 
 
704
    def _set_path(self, *args):
 
705
        path = os.pathsep.join(self._list2paths(*args))
 
706
        self.overrideEnv('BZR_PLUGIN_PATH', path)
 
707
 
 
708
    def check_path(self, expected_dirs, setting_dirs):
 
709
        if setting_dirs:
 
710
            self._set_path(*setting_dirs)
 
711
        actual = plugin.get_standard_plugins_path()
 
712
        self.assertEquals(self._list2paths(*expected_dirs), actual)
 
713
 
 
714
    def test_default(self):
 
715
        self.check_path([self.user, self.core, self.site],
 
716
                        None)
 
717
 
 
718
    def test_adhoc_policy(self):
 
719
        self.check_path([self.user, self.core, self.site],
 
720
                        ['+user', '+core', '+site'])
 
721
 
 
722
    def test_fallback_policy(self):
 
723
        self.check_path([self.core, self.site, self.user],
 
724
                        ['+core', '+site', '+user'])
 
725
 
 
726
    def test_override_policy(self):
 
727
        self.check_path([self.user, self.site, self.core],
 
728
                        ['+user', '+site', '+core'])
 
729
 
 
730
    def test_disable_user(self):
 
731
        self.check_path([self.core, self.site], ['-user'])
 
732
 
 
733
    def test_disable_user_twice(self):
 
734
        # Ensures multiple removals don't left cruft
 
735
        self.check_path([self.core, self.site], ['-user', '-user'])
 
736
 
 
737
    def test_duplicates_are_removed(self):
 
738
        self.check_path([self.user, self.core, self.site],
 
739
                        ['+user', '+user'])
 
740
        # And only the first reference is kept (since the later references will
 
741
        # only produce '<plugin> already loaded' mutters)
 
742
        self.check_path([self.user, self.core, self.site],
 
743
                        ['+user', '+user', '+core',
 
744
                         '+user', '+site', '+site',
 
745
                         '+core'])
 
746
 
 
747
    def test_disable_overrides_enable(self):
 
748
        self.check_path([self.core, self.site], ['-user', '+user'])
 
749
 
 
750
    def test_disable_core(self):
 
751
        self.check_path([self.site], ['-core'])
 
752
        self.check_path([self.user, self.site], ['+user', '-core'])
 
753
 
 
754
    def test_disable_site(self):
 
755
        self.check_path([self.core], ['-site'])
 
756
        self.check_path([self.user, self.core], ['-site', '+user'])
 
757
 
 
758
    def test_override_site(self):
 
759
        self.check_path(['mysite', self.user, self.core],
 
760
                        ['mysite', '-site', '+user'])
 
761
        self.check_path(['mysite', self.core],
 
762
                        ['mysite', '-site'])
 
763
 
 
764
    def test_override_core(self):
 
765
        self.check_path(['mycore', self.user, self.site],
 
766
                        ['mycore', '-core', '+user', '+site'])
 
767
        self.check_path(['mycore', self.site],
 
768
                        ['mycore', '-core'])
 
769
 
 
770
    def test_my_plugin_only(self):
 
771
        self.check_path(['myplugin'], ['myplugin', '-user', '-core', '-site'])
 
772
 
 
773
    def test_my_plugin_first(self):
 
774
        self.check_path(['myplugin', self.core, self.site, self.user],
 
775
                        ['myplugin', '+core', '+site', '+user'])
 
776
 
 
777
    def test_bogus_references(self):
 
778
        self.check_path(['+foo', '-bar', self.core, self.site],
 
779
                        ['+foo', '-bar'])
 
780
 
 
781
 
 
782
class TestDisablePlugin(BaseTestPlugins):
 
783
 
 
784
    def setUp(self):
 
785
        super(TestDisablePlugin, self).setUp()
 
786
        self.create_plugin_package('test_foo')
 
787
        # Make sure we don't pollute the plugins namespace
 
788
        self.overrideAttr(plugins, '__path__')
 
789
        # Be paranoid in case a test fail
 
790
        self.addCleanup(self._unregister_plugin, 'test_foo')
 
791
 
 
792
    def test_cannot_import(self):
 
793
        self.overrideEnv('BZR_DISABLE_PLUGINS', 'test_foo')
 
794
        plugin.set_plugins_path(['.'])
 
795
        try:
 
796
            import bzrlib.plugins.test_foo
 
797
        except ImportError:
 
798
            pass
 
799
        self.assertPluginUnknown('test_foo')
 
800
 
 
801
    def test_regular_load(self):
 
802
        self.overrideAttr(plugin, '_loaded', False)
 
803
        plugin.load_plugins(['.'])
 
804
        self.assertPluginKnown('test_foo')
 
805
        self.assertDocstring("This is the doc for test_foo",
 
806
                             bzrlib.plugins.test_foo)
 
807
 
 
808
    def test_not_loaded(self):
 
809
        self.warnings = []
 
810
        def captured_warning(*args, **kwargs):
 
811
            self.warnings.append((args, kwargs))
 
812
        self.overrideAttr(trace, 'warning', captured_warning)
 
813
        # Reset the flag that protect against double loading
 
814
        self.overrideAttr(plugin, '_loaded', False)
 
815
        self.overrideEnv('BZR_DISABLE_PLUGINS', 'test_foo')
 
816
        plugin.load_plugins(['.'])
 
817
        self.assertPluginUnknown('test_foo')
 
818
        # Make sure we don't warn about the plugin ImportError since this has
 
819
        # been *requested* by the user.
 
820
        self.assertLength(0, self.warnings)
 
821
 
 
822
 
 
823
 
 
824
class TestLoadPluginAtSyntax(tests.TestCase):
 
825
 
 
826
    def _get_paths(self, paths):
 
827
        return plugin._get_specific_plugin_paths(paths)
 
828
 
 
829
    def test_empty(self):
 
830
        self.assertEquals([], self._get_paths(None))
 
831
        self.assertEquals([], self._get_paths(''))
 
832
 
 
833
    def test_one_path(self):
 
834
        self.assertEquals([('b', 'man')], self._get_paths('b@man'))
 
835
 
 
836
    def test_bogus_path(self):
 
837
        # We need a '@'
 
838
        self.assertRaises(errors.BzrCommandError, self._get_paths, 'batman')
 
839
        # Too much '@' isn't good either
 
840
        self.assertRaises(errors.BzrCommandError, self._get_paths,
 
841
                          'batman@mobile@cave')
 
842
        # An empty description probably indicates a problem
 
843
        self.assertRaises(errors.BzrCommandError, self._get_paths,
 
844
                          os.pathsep.join(['batman@cave', '', 'robin@mobile']))
 
845
 
 
846
 
 
847
class TestLoadPluginAt(BaseTestPlugins):
 
848
 
 
849
    def setUp(self):
 
850
        super(TestLoadPluginAt, self).setUp()
 
851
        # Make sure we don't pollute the plugins namespace
 
852
        self.overrideAttr(plugins, '__path__')
 
853
        # Reset the flag that protect against double loading
 
854
        self.overrideAttr(plugin, '_loaded', False)
 
855
        # Create the same plugin in two directories
 
856
        self.create_plugin_package('test_foo', dir='non-standard-dir')
 
857
        # The "normal" directory, we use 'standard' instead of 'plugins' to
 
858
        # avoid depending on the precise naming.
 
859
        self.create_plugin_package('test_foo', dir='standard/test_foo')
 
860
        # All the tests will load the 'test_foo' plugin from various locations
 
861
        self.addCleanup(self._unregister_plugin, 'test_foo')
 
862
        # Unfortunately there's global cached state for the specific
 
863
        # registered paths.
 
864
        self.addCleanup(plugin.PluginImporter.reset)
 
865
 
 
866
    def assertTestFooLoadedFrom(self, path):
 
867
        self.assertPluginKnown('test_foo')
 
868
        self.assertDocstring('This is the doc for test_foo',
 
869
                             bzrlib.plugins.test_foo)
 
870
        self.assertEqual(path, bzrlib.plugins.test_foo.dir_source)
 
871
 
 
872
    def test_regular_load(self):
 
873
        plugin.load_plugins(['standard'])
 
874
        self.assertTestFooLoadedFrom('standard/test_foo')
 
875
 
 
876
    def test_import(self):
 
877
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
878
        plugin.set_plugins_path(['standard'])
 
879
        try:
 
880
            import bzrlib.plugins.test_foo
 
881
        except ImportError:
 
882
            pass
 
883
        self.assertTestFooLoadedFrom('non-standard-dir')
 
884
 
 
885
    def test_loading(self):
 
886
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
887
        plugin.load_plugins(['standard'])
 
888
        self.assertTestFooLoadedFrom('non-standard-dir')
 
889
 
 
890
    def test_compiled_loaded(self):
 
891
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
892
        plugin.load_plugins(['standard'])
 
893
        self.assertTestFooLoadedFrom('non-standard-dir')
 
894
        self.assertIsSameRealPath('non-standard-dir/__init__.py',
 
895
                                  bzrlib.plugins.test_foo.__file__)
 
896
 
 
897
        # Try importing again now that the source has been compiled
 
898
        self._unregister_plugin('test_foo')
 
899
        plugin._loaded = False
 
900
        plugin.load_plugins(['standard'])
 
901
        self.assertTestFooLoadedFrom('non-standard-dir')
 
902
        if __debug__:
 
903
            suffix = 'pyc'
 
904
        else:
 
905
            suffix = 'pyo'
 
906
        self.assertIsSameRealPath('non-standard-dir/__init__.%s' % suffix,
 
907
                                  bzrlib.plugins.test_foo.__file__)
 
908
 
 
909
    def test_submodule_loading(self):
 
910
        # We create an additional directory under the one for test_foo
 
911
        self.create_plugin_package('test_bar', dir='non-standard-dir/test_bar')
 
912
        self.addCleanup(self._unregister_plugin_submodule,
 
913
                        'test_foo', 'test_bar')
 
914
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
915
        plugin.set_plugins_path(['standard'])
 
916
        import bzrlib.plugins.test_foo
 
917
        self.assertEqual('bzrlib.plugins.test_foo',
 
918
                         bzrlib.plugins.test_foo.__package__)
 
919
        import bzrlib.plugins.test_foo.test_bar
 
920
        self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
 
921
                                  bzrlib.plugins.test_foo.test_bar.__file__)
 
922
 
 
923
    def test_relative_submodule_loading(self):
 
924
        self.create_plugin_package('test_foo', dir='another-dir', source='''
 
925
import test_bar
 
926
''')
 
927
        # We create an additional directory under the one for test_foo
 
928
        self.create_plugin_package('test_bar', dir='another-dir/test_bar')
 
929
        self.addCleanup(self._unregister_plugin_submodule,
 
930
                        'test_foo', 'test_bar')
 
931
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@another-dir')
 
932
        plugin.set_plugins_path(['standard'])
 
933
        import bzrlib.plugins.test_foo
 
934
        self.assertEqual('bzrlib.plugins.test_foo',
 
935
                         bzrlib.plugins.test_foo.__package__)
 
936
        self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
 
937
                                  bzrlib.plugins.test_foo.test_bar.__file__)
 
938
 
 
939
    def test_loading_from___init__only(self):
 
940
        # We rename the existing __init__.py file to ensure that we don't load
 
941
        # a random file
 
942
        init = 'non-standard-dir/__init__.py'
 
943
        random = 'non-standard-dir/setup.py'
 
944
        os.rename(init, random)
 
945
        self.addCleanup(os.rename, random, init)
 
946
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
 
947
        plugin.load_plugins(['standard'])
 
948
        self.assertPluginUnknown('test_foo')
 
949
 
 
950
    def test_loading_from_specific_file(self):
 
951
        plugin_dir = 'non-standard-dir'
 
952
        plugin_file_name = 'iamtestfoo.py'
 
953
        plugin_path = osutils.pathjoin(plugin_dir, plugin_file_name)
 
954
        source = '''\
 
955
"""This is the doc for %s"""
 
956
dir_source = '%s'
 
957
''' % ('test_foo', plugin_path)
 
958
        self.create_plugin('test_foo', source=source,
 
959
                           dir=plugin_dir, file_name=plugin_file_name)
 
960
        self.overrideEnv('BZR_PLUGINS_AT', 'test_foo@%s' % plugin_path)
 
961
        plugin.load_plugins(['standard'])
 
962
        self.assertTestFooLoadedFrom(plugin_path)
 
963
 
 
964
 
 
965
class TestDescribePlugins(BaseTestPlugins):
 
966
 
 
967
    def test_describe_plugins(self):
 
968
        class DummyModule(object):
 
969
            __doc__ = 'Hi there'
 
970
        class DummyPlugin(object):
 
971
            __version__ = '0.1.0'
 
972
            module = DummyModule()
 
973
        def dummy_plugins():
 
974
            return { 'good': DummyPlugin() }
 
975
        self.overrideAttr(plugin, 'plugin_warnings',
 
976
            {'bad': ['Failed to load (just testing)']})
 
977
        self.overrideAttr(plugin, 'plugins', dummy_plugins)
 
978
        self.assertEquals("""\
 
979
bad (failed to load)
 
980
  ** Failed to load (just testing)
 
981
 
 
982
good 0.1.0
 
983
  Hi there
 
984
 
 
985
""", ''.join(plugin.describe_plugins()))