← 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: Ian Clatworthy
  • Date: 2010-05-26 04:26:59 UTC
  • mto: (5255.2.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5256.
  • Revision ID: ian.clatworthy@canonical.com-20100526042659-2e3p4qdjr0sby0bt
https://launchpad.net/bugs/486990
Fix PDF generation of User Reference

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
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
    osutils,
 
31
    plugin,
 
32
    plugins,
 
33
    tests,
 
34
    trace,
38
35
    )
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
 
"""
 
36
 
50
37
 
51
38
# TODO: Write a test for plugin decoration of commands.
52
39
 
53
 
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):
54
92
 
55
93
    activeattributes = {}
56
94
 
64
102
        # set a place for the plugins to record their loading, and at the same
65
103
        # time validate that the location the plugins should record to is
66
104
        # valid and correct.
67
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
68
 
            [tempattribute] = []
 
105
        self.__class__.activeattributes [tempattribute] = []
69
106
        self.failUnless(tempattribute in self.activeattributes)
70
107
        # create two plugin directories
71
108
        os.mkdir('first')
95
132
        finally:
96
133
            # remove the plugin 'plugin'
97
134
            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))
 
135
            self._unregister_plugin('plugin')
 
136
        self.assertPluginUnknown('plugin')
103
137
 
104
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)
105
141
        # This test tests that having two plugins in different
106
142
        # directories with different names allows them both to be loaded, when
107
143
        # we do a direct import statement.
139
175
 
140
176
        oldpath = bzrlib.plugins.__path__
141
177
        try:
 
178
            self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
179
            self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
142
180
            bzrlib.plugins.__path__ = ['first', 'second']
143
181
            exec "import bzrlib.plugins.pluginone"
144
182
            self.assertEqual(['first'], self.activeattributes[tempattribute])
148
186
        finally:
149
187
            # remove the plugin 'plugin'
150
188
            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))
 
189
            self._unregister_plugin('pluginone')
 
190
            self._unregister_plugin('plugintwo')
 
191
        self.assertPluginUnknown('pluginone')
 
192
        self.assertPluginUnknown('plugintwo')
157
193
 
158
194
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
159
195
        # This test tests that a plugin can load from a directory when the
160
196
        # directory in the path has a trailing slash.
161
197
        # check the plugin is not loaded already
162
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
198
        self.assertPluginUnknown('ts_plugin')
163
199
        tempattribute = "trailing-slash"
164
200
        self.failIf(tempattribute in self.activeattributes)
165
201
        # set a place for the plugin to record its loading, and at the same
186
222
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
187
223
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
188
224
        finally:
189
 
            # remove the plugin 'plugin'
190
225
            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))
 
226
            self._unregister_plugin('ts_plugin')
 
227
        self.assertPluginUnknown('ts_plugin')
194
228
 
195
229
    def load_and_capture(self, name):
196
230
        """Load plugins from '.' capturing the output.
247
281
            "it to 'bad_plugin_name_'\.")
248
282
 
249
283
 
250
 
class TestPlugins(TestCaseInTempDir):
 
284
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
251
285
 
252
286
    def setup_plugin(self, source=""):
253
287
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
254
288
        # check the plugin is not loaded already
255
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
289
        self.assertPluginUnknown('plugin')
256
290
        # write a plugin that _cannot_ fail to load.
257
291
        file('plugin.py', 'w').write(source + '\n')
258
292
        self.addCleanup(self.teardown_plugin)
259
 
        bzrlib.plugin.load_from_path(['.'])
 
293
        plugin.load_from_path(['.'])
260
294
 
261
295
    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))
 
296
        self._unregister_plugin('plugin')
 
297
        self.assertPluginUnknown('plugin')
268
298
 
269
299
    def test_plugin_appears_in_plugins(self):
270
300
        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)
 
301
        self.assertPluginKnown('plugin')
 
302
        p = plugin.plugins()['plugin']
 
303
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
 
304
        self.assertEqual(p.module, plugins.plugin)
277
305
 
278
306
    def test_trivial_plugin_get_path(self):
279
307
        self.setup_plugin()
280
 
        plugins = bzrlib.plugin.plugins()
281
 
        plugin = plugins['plugin']
 
308
        p = plugin.plugins()['plugin']
282
309
        plugin_path = self.test_dir + '/plugin.py'
283
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
310
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
284
311
 
285
312
    def test_plugin_get_path_py_not_pyc(self):
286
 
        self.setup_plugin()         # after first import there will be plugin.pyc
 
313
        # first import creates plugin.pyc
 
314
        self.setup_plugin()
287
315
        self.teardown_plugin()
288
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
289
 
        plugins = bzrlib.plugin.plugins()
290
 
        plugin = plugins['plugin']
 
316
        plugin.load_from_path(['.']) # import plugin.pyc
 
317
        p = plugin.plugins()['plugin']
291
318
        plugin_path = self.test_dir + '/plugin.py'
292
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
319
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
293
320
 
294
321
    def test_plugin_get_path_pyc_only(self):
295
 
        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()
296
324
        self.teardown_plugin()
297
325
        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']
 
326
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
327
        p = plugin.plugins()['plugin']
301
328
        if __debug__:
302
329
            plugin_path = self.test_dir + '/plugin.pyc'
303
330
        else:
304
331
            plugin_path = self.test_dir + '/plugin.pyo'
305
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
 
332
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
306
333
 
307
334
    def test_no_test_suite_gives_None_for_test_suite(self):
308
335
        self.setup_plugin()
309
 
        plugin = bzrlib.plugin.plugins()['plugin']
310
 
        self.assertEqual(None, plugin.test_suite())
 
336
        p = plugin.plugins()['plugin']
 
337
        self.assertEqual(None, p.test_suite())
311
338
 
312
339
    def test_test_suite_gives_test_suite_result(self):
313
340
        source = """def test_suite(): return 'foo'"""
314
341
        self.setup_plugin(source)
315
 
        plugin = bzrlib.plugin.plugins()['plugin']
316
 
        self.assertEqual('foo', plugin.test_suite())
 
342
        p = plugin.plugins()['plugin']
 
343
        self.assertEqual('foo', p.test_suite())
317
344
 
318
345
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
319
346
        self.setup_plugin()
320
 
        loader = TestUtil.TestLoader()
321
 
        plugin = bzrlib.plugin.plugins()['plugin']
322
 
        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))
323
350
 
324
351
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
325
352
        source = """
326
353
def load_tests(standard_tests, module, loader):
327
354
    return 'foo'"""
328
355
        self.setup_plugin(source)
329
 
        loader = TestUtil.TestLoader()
330
 
        plugin = bzrlib.plugin.plugins()['plugin']
331
 
        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())
332
363
 
333
364
    def test_no_version_info(self):
334
 
        self.setup_plugin()
335
 
        plugin = bzrlib.plugin.plugins()['plugin']
336
 
        self.assertEqual(None, plugin.version_info())
 
365
        self.check_version_info(None)
337
366
 
338
367
    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())
 
368
        self.check_version_info((1, 2, 3, 'dev', 4),
 
369
                                "version_info = (1, 2, 3, 'dev', 4)")
342
370
 
343
371
    def test_short_version_info_gets_padded(self):
344
372
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
345
373
        # 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())
 
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__)
349
380
 
350
381
    def test_no_version_info___version__(self):
351
382
        self.setup_plugin()
390
421
    def test_dev_fallback__version__with_version_info(self):
391
422
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
392
423
        plugin = bzrlib.plugin.plugins()['plugin']
393
 
        self.assertEqual("1.2.3.dev.4", plugin.__version__)
 
424
        self.assertEqual("1.2.3dev4", plugin.__version__)
394
425
 
395
426
    def test_final__version__with_version_info(self):
396
427
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
397
428
        plugin = bzrlib.plugin.plugins()['plugin']
398
429
        self.assertEqual("1.2.3", plugin.__version__)
399
430
 
400
 
 
401
 
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):
402
438
 
403
439
    def split_help_commands(self):
404
440
        help = {}
433
469
    def test_plugin_help_shows_plugin(self):
434
470
        # Create a test plugin
435
471
        os.mkdir('plugin_test')
436
 
        f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
437
 
        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
)
438
483
        f.close()
439
484
 
440
485
        try:
454
499
                delattr(bzrlib.plugins, 'myplug')
455
500
 
456
501
 
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
502
class TestHelpIndex(tests.TestCase):
493
503
    """Tests for the PluginsHelpIndex class."""
494
504
 
597
607
        self.assertEqual('foo_bar', topic.get_help_topic())
598
608
 
599
609
 
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):
 
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
620
 
621
621
    def test_set_plugins_path_with_args(self):
622
 
        clear_plugins(self)
623
622
        plugin.set_plugins_path(['a', 'b'])
624
623
        self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
625
624
 
626
625
    def test_set_plugins_path_defaults(self):
627
 
        clear_plugins(self)
628
626
        plugin.set_plugins_path()
629
627
        self.assertEqual(plugin.get_standard_plugins_path(),
630
628
                         bzrlib.plugins.__path__)
631
629
 
632
630
    def test_get_standard_plugins_path(self):
633
631
        path = plugin.get_standard_plugins_path()
634
 
        self.assertEqual(plugin.get_default_plugin_path(), path[0])
635
632
        for directory in path:
636
 
            self.assertNotContainsRe(r'\\/$', directory)
 
633
            self.assertNotContainsRe(directory, r'\\/$')
637
634
        try:
638
635
            from distutils.sysconfig import get_python_lib
639
636
        except ImportError:
649
646
 
650
647
    def test_get_standard_plugins_path_env(self):
651
648
        os.environ['BZR_PLUGIN_PATH'] = 'foo/'
652
 
        self.assertEqual('foo', plugin.get_standard_plugins_path()[0])
653
 
 
654
 
 
655
 
class TestLoadPlugins(tests.TestCaseInTempDir):
 
649
        path = plugin.get_standard_plugins_path()
 
650
        for directory in path:
 
651
            self.assertNotContainsRe(directory, r'\\/$')
656
652
 
657
653
    def test_load_plugins(self):
658
 
        clear_plugins(self)
659
654
        plugin.load_plugins(['.'])
660
655
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
661
656
        # subsequent loads are no-ops
663
658
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
664
659
 
665
660
    def test_load_plugins_default(self):
666
 
        clear_plugins(self)
667
661
        plugin.load_plugins()
668
662
        path = plugin.get_standard_plugins_path()
669
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.assertIsSameRealPath('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.assertIsSameRealPath('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.assertIsSameRealPath('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)