← 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: Daniel Watkins
  • Date: 2007-08-02 18:04:35 UTC
  • mto: This revision was merged to the branch mainline in revision 2705.
  • Revision ID: d.m.watkins@warwick.ac.uk-20070802180435-cs6xalg5tkze209b
tests.blackbox.test_aliases now uses internals where appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 
import logging
24
23
import os
25
24
from StringIO import StringIO
26
25
import sys
27
26
import zipfile
28
27
 
29
 
from bzrlib import (
30
 
    osutils,
31
 
    plugin,
32
 
    tests,
33
 
    )
 
28
from bzrlib import plugin, tests
34
29
import bzrlib.plugin
35
30
import bzrlib.plugins
36
31
import bzrlib.commands
37
32
import bzrlib.help
38
 
from bzrlib.tests import (
39
 
    TestCase,
40
 
    TestCaseInTempDir,
41
 
    TestUtil,
42
 
    )
43
 
from bzrlib.osutils import pathjoin, abspath, normpath
 
33
from bzrlib.tests import TestCase, TestCaseInTempDir
 
34
from bzrlib.osutils import pathjoin, abspath
44
35
 
45
36
 
46
37
PLUGIN_TEXT = """\
74
65
        # create two plugin directories
75
66
        os.mkdir('first')
76
67
        os.mkdir('second')
77
 
        # write a plugin that will record when its loaded in the
 
68
        # write a plugin that will record when its loaded in the 
78
69
        # tempattribute list.
79
70
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
80
71
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
81
 
 
82
 
        outfile = open(os.path.join('first', 'plugin.py'), 'w')
83
 
        try:
84
 
            outfile.write(template % (tempattribute, 'first'))
85
 
            outfile.write('\n')
86
 
        finally:
87
 
            outfile.close()
88
 
 
89
 
        outfile = open(os.path.join('second', 'plugin.py'), 'w')
90
 
        try:
91
 
            outfile.write(template % (tempattribute, 'second'))
92
 
            outfile.write('\n')
93
 
        finally:
94
 
            outfile.close()
95
 
 
 
72
        print >> file(os.path.join('first', 'plugin.py'), 'w'), template % (tempattribute, 'first')
 
73
        print >> file(os.path.join('second', 'plugin.py'), 'w'), template % (tempattribute, 'second')
96
74
        try:
97
75
            bzrlib.plugin.load_from_path(['first', 'second'])
98
76
            self.assertEqual(['first'], self.activeattributes[tempattribute])
99
77
        finally:
100
78
            # remove the plugin 'plugin'
101
79
            del self.activeattributes[tempattribute]
102
 
            if 'bzrlib.plugins.plugin' in sys.modules:
103
 
                del sys.modules['bzrlib.plugins.plugin']
104
80
            if getattr(bzrlib.plugins, 'plugin', None):
105
81
                del bzrlib.plugins.plugin
106
82
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
122
98
        # create two plugin directories
123
99
        os.mkdir('first')
124
100
        os.mkdir('second')
125
 
        # write plugins that will record when they are loaded in the
 
101
        # write plugins that will record when they are loaded in the 
126
102
        # tempattribute list.
127
103
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
128
104
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
129
 
 
130
 
        outfile = open(os.path.join('first', 'pluginone.py'), 'w')
131
 
        try:
132
 
            outfile.write(template % (tempattribute, 'first'))
133
 
            outfile.write('\n')
134
 
        finally:
135
 
            outfile.close()
136
 
 
137
 
        outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
138
 
        try:
139
 
            outfile.write(template % (tempattribute, 'second'))
140
 
            outfile.write('\n')
141
 
        finally:
142
 
            outfile.close()
143
 
 
 
105
        print >> file(os.path.join('first', 'pluginone.py'), 'w'), template % (tempattribute, 'first')
 
106
        print >> file(os.path.join('second', 'plugintwo.py'), 'w'), template % (tempattribute, 'second')
144
107
        oldpath = bzrlib.plugins.__path__
145
108
        try:
146
109
            bzrlib.plugins.__path__ = ['first', 'second']
152
115
        finally:
153
116
            # remove the plugin 'plugin'
154
117
            del self.activeattributes[tempattribute]
155
 
            if getattr(bzrlib.plugins, 'pluginone', None):
156
 
                del bzrlib.plugins.pluginone
157
 
            if getattr(bzrlib.plugins, 'plugintwo', None):
158
 
                del bzrlib.plugins.plugintwo
159
 
        self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
160
 
        self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
161
 
 
162
 
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
163
 
        # This test tests that a plugin can load from a directory when the
164
 
        # directory in the path has a trailing slash.
165
 
        # check the plugin is not loaded already
166
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
167
 
        tempattribute = "trailing-slash"
168
 
        self.failIf(tempattribute in self.activeattributes)
169
 
        # set a place for the plugin to record its loading, and at the same
170
 
        # time validate that the location the plugin should record to is
171
 
        # valid and correct.
172
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
173
 
            [tempattribute] = []
174
 
        self.failUnless(tempattribute in self.activeattributes)
175
 
        # create a directory for the plugin
176
 
        os.mkdir('plugin_test')
177
 
        # write a plugin that will record when its loaded in the
178
 
        # tempattribute list.
179
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
180
 
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
181
 
 
182
 
        outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
183
 
        try:
184
 
            outfile.write(template % (tempattribute, 'plugin'))
185
 
            outfile.write('\n')
186
 
        finally:
187
 
            outfile.close()
188
 
 
189
 
        try:
190
 
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
191
 
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
192
 
        finally:
193
 
            # remove the plugin 'plugin'
194
 
            del self.activeattributes[tempattribute]
195
 
            if getattr(bzrlib.plugins, 'ts_plugin', None):
196
 
                del bzrlib.plugins.ts_plugin
197
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
198
 
 
199
 
    def load_and_capture(self, name):
200
 
        """Load plugins from '.' capturing the output.
201
 
 
202
 
        :param name: The name of the plugin.
203
 
        :return: A string with the log from the plugin loading call.
204
 
        """
205
 
        # Capture output
206
 
        stream = StringIO()
207
 
        try:
208
 
            handler = logging.StreamHandler(stream)
209
 
            log = logging.getLogger('bzr')
210
 
            log.addHandler(handler)
211
 
            try:
212
 
                try:
213
 
                    bzrlib.plugin.load_from_path(['.'])
214
 
                finally:
215
 
                    if 'bzrlib.plugins.%s' % name in sys.modules:
216
 
                        del sys.modules['bzrlib.plugins.%s' % name]
217
 
                    if getattr(bzrlib.plugins, name, None):
218
 
                        delattr(bzrlib.plugins, name)
219
 
            finally:
220
 
                # Stop capturing output
221
 
                handler.flush()
222
 
                handler.close()
223
 
                log.removeHandler(handler)
224
 
            return stream.getvalue()
225
 
        finally:
226
 
            stream.close()
227
 
 
228
 
    def test_plugin_with_bad_api_version_reports(self):
229
 
        # This plugin asks for bzrlib api version 1.0.0, which is not supported
230
 
        # anymore.
231
 
        name = 'wants100.py'
232
 
        f = file(name, 'w')
233
 
        try:
234
 
            f.write("import bzrlib.api\n"
235
 
                "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
236
 
        finally:
237
 
            f.close()
238
 
 
239
 
        log = self.load_and_capture(name)
240
 
        self.assertContainsRe(log,
241
 
            r"It requested API version")
242
 
 
243
 
    def test_plugin_with_bad_name_does_not_load(self):
244
 
        # The file name here invalid for a python module.
245
 
        name = 'bzr-bad plugin-name..py'
246
 
        file(name, 'w').close()
247
 
        log = self.load_and_capture(name)
248
 
        self.assertContainsRe(log,
249
 
            r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
250
 
            "because the file path isn't a valid module name; try renaming "
251
 
            "it to 'bad_plugin_name_'\.")
252
 
 
253
 
 
254
 
class TestPlugins(TestCaseInTempDir):
255
 
 
256
 
    def setup_plugin(self, source=""):
257
 
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
 
118
            if getattr(bzrlib.plugins, 'plugin', None):
 
119
                del bzrlib.plugins.plugin
 
120
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
121
 
 
122
 
 
123
class TestAllPlugins(TestCaseInTempDir):
 
124
 
 
125
    def test_plugin_appears_in_all_plugins(self):
 
126
        # This test tests a new plugin appears in bzrlib.plugin.all_plugins().
258
127
        # check the plugin is not loaded already
259
128
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
260
129
        # write a plugin that _cannot_ fail to load.
261
 
        file('plugin.py', 'w').write(source + '\n')
262
 
        self.addCleanup(self.teardown_plugin)
263
 
        bzrlib.plugin.load_from_path(['.'])
264
 
 
265
 
    def teardown_plugin(self):
266
 
        # remove the plugin 'plugin'
267
 
        if 'bzrlib.plugins.plugin' in sys.modules:
268
 
            del sys.modules['bzrlib.plugins.plugin']
269
 
        if getattr(bzrlib.plugins, 'plugin', None):
270
 
            del bzrlib.plugins.plugin
 
130
        print >> file('plugin.py', 'w'), ""
 
131
        try:
 
132
            bzrlib.plugin.load_from_path(['.'])
 
133
            self.failUnless('plugin' in bzrlib.plugin.all_plugins())
 
134
            self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
 
135
            self.assertEqual(bzrlib.plugin.all_plugins()['plugin'],
 
136
                             bzrlib.plugins.plugin)
 
137
        finally:
 
138
            # remove the plugin 'plugin'
 
139
            if 'bzrlib.plugins.plugin' in sys.modules:
 
140
                del sys.modules['bzrlib.plugins.plugin']
 
141
            if getattr(bzrlib.plugins, 'plugin', None):
 
142
                del bzrlib.plugins.plugin
271
143
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
272
144
 
273
 
    def test_plugin_appears_in_plugins(self):
274
 
        self.setup_plugin()
275
 
        self.failUnless('plugin' in bzrlib.plugin.plugins())
276
 
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
277
 
        plugins = bzrlib.plugin.plugins()
278
 
        plugin = plugins['plugin']
279
 
        self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
280
 
        self.assertEqual(bzrlib.plugins.plugin, plugin.module)
281
 
 
282
 
    def test_trivial_plugin_get_path(self):
283
 
        self.setup_plugin()
284
 
        plugins = bzrlib.plugin.plugins()
285
 
        plugin = plugins['plugin']
286
 
        plugin_path = self.test_dir + '/plugin.py'
287
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
288
 
 
289
 
    def test_plugin_get_path_py_not_pyc(self):
290
 
        self.setup_plugin()         # after first import there will be plugin.pyc
291
 
        self.teardown_plugin()
292
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
293
 
        plugins = bzrlib.plugin.plugins()
294
 
        plugin = plugins['plugin']
295
 
        plugin_path = self.test_dir + '/plugin.py'
296
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
297
 
 
298
 
    def test_plugin_get_path_pyc_only(self):
299
 
        self.setup_plugin()         # after first import there will be plugin.pyc
300
 
        self.teardown_plugin()
301
 
        os.unlink(self.test_dir + '/plugin.py')
302
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
303
 
        plugins = bzrlib.plugin.plugins()
304
 
        plugin = plugins['plugin']
305
 
        if __debug__:
306
 
            plugin_path = self.test_dir + '/plugin.pyc'
307
 
        else:
308
 
            plugin_path = self.test_dir + '/plugin.pyo'
309
 
        self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
310
 
 
311
 
    def test_no_test_suite_gives_None_for_test_suite(self):
312
 
        self.setup_plugin()
313
 
        plugin = bzrlib.plugin.plugins()['plugin']
314
 
        self.assertEqual(None, plugin.test_suite())
315
 
 
316
 
    def test_test_suite_gives_test_suite_result(self):
317
 
        source = """def test_suite(): return 'foo'"""
318
 
        self.setup_plugin(source)
319
 
        plugin = bzrlib.plugin.plugins()['plugin']
320
 
        self.assertEqual('foo', plugin.test_suite())
321
 
 
322
 
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
323
 
        self.setup_plugin()
324
 
        loader = TestUtil.TestLoader()
325
 
        plugin = bzrlib.plugin.plugins()['plugin']
326
 
        self.assertEqual(None, plugin.load_plugin_tests(loader))
327
 
 
328
 
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
329
 
        source = """
330
 
def load_tests(standard_tests, module, loader):
331
 
    return 'foo'"""
332
 
        self.setup_plugin(source)
333
 
        loader = TestUtil.TestLoader()
334
 
        plugin = bzrlib.plugin.plugins()['plugin']
335
 
        self.assertEqual('foo', plugin.load_plugin_tests(loader))
336
 
 
337
 
    def test_no_version_info(self):
338
 
        self.setup_plugin()
339
 
        plugin = bzrlib.plugin.plugins()['plugin']
340
 
        self.assertEqual(None, plugin.version_info())
341
 
 
342
 
    def test_with_version_info(self):
343
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
344
 
        plugin = bzrlib.plugin.plugins()['plugin']
345
 
        self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
346
 
 
347
 
    def test_short_version_info_gets_padded(self):
348
 
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
349
 
        # so we adapt it
350
 
        self.setup_plugin("version_info = (1, 2, 3)")
351
 
        plugin = bzrlib.plugin.plugins()['plugin']
352
 
        self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
353
 
 
354
 
    def test_no_version_info___version__(self):
355
 
        self.setup_plugin()
356
 
        plugin = bzrlib.plugin.plugins()['plugin']
357
 
        self.assertEqual("unknown", plugin.__version__)
358
 
 
359
 
    def test_str__version__with_version_info(self):
360
 
        self.setup_plugin("version_info = '1.2.3'")
361
 
        plugin = bzrlib.plugin.plugins()['plugin']
362
 
        self.assertEqual("1.2.3", plugin.__version__)
363
 
 
364
 
    def test_noniterable__version__with_version_info(self):
365
 
        self.setup_plugin("version_info = (1)")
366
 
        plugin = bzrlib.plugin.plugins()['plugin']
367
 
        self.assertEqual("1", plugin.__version__)
368
 
 
369
 
    def test_1__version__with_version_info(self):
370
 
        self.setup_plugin("version_info = (1,)")
371
 
        plugin = bzrlib.plugin.plugins()['plugin']
372
 
        self.assertEqual("1", plugin.__version__)
373
 
 
374
 
    def test_1_2__version__with_version_info(self):
375
 
        self.setup_plugin("version_info = (1, 2)")
376
 
        plugin = bzrlib.plugin.plugins()['plugin']
377
 
        self.assertEqual("1.2", plugin.__version__)
378
 
 
379
 
    def test_1_2_3__version__with_version_info(self):
380
 
        self.setup_plugin("version_info = (1, 2, 3)")
381
 
        plugin = bzrlib.plugin.plugins()['plugin']
382
 
        self.assertEqual("1.2.3", plugin.__version__)
383
 
 
384
 
    def test_candidate__version__with_version_info(self):
385
 
        self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
386
 
        plugin = bzrlib.plugin.plugins()['plugin']
387
 
        self.assertEqual("1.2.3rc1", plugin.__version__)
388
 
 
389
 
    def test_dev__version__with_version_info(self):
390
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
391
 
        plugin = bzrlib.plugin.plugins()['plugin']
392
 
        self.assertEqual("1.2.3dev", plugin.__version__)
393
 
 
394
 
    def test_dev_fallback__version__with_version_info(self):
395
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
396
 
        plugin = bzrlib.plugin.plugins()['plugin']
397
 
        self.assertEqual("1.2.3dev4", plugin.__version__)
398
 
 
399
 
    def test_final__version__with_version_info(self):
400
 
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
401
 
        plugin = bzrlib.plugin.plugins()['plugin']
402
 
        self.assertEqual("1.2.3", plugin.__version__)
403
 
 
404
 
    def test_final_fallback__version__with_version_info(self):
405
 
        self.setup_plugin("version_info = (1, 2, 3, 'final', 2)")
406
 
        plugin = bzrlib.plugin.plugins()['plugin']
407
 
        self.assertEqual("1.2.3.final.2", plugin.__version__)
408
 
 
409
145
 
410
146
class TestPluginHelp(TestCaseInTempDir):
411
147
 
412
148
    def split_help_commands(self):
413
149
        help = {}
414
150
        current = None
415
 
        out, err = self.run_bzr('--no-plugins help commands')
416
 
        for line in out.splitlines():
 
151
        for line in self.run_bzr('help commands')[0].splitlines():
417
152
            if not line.startswith(' '):
418
153
                current = line.split()[0]
419
154
            help[current] = help.get(current, '') + line
432
167
                # some commands have no help
433
168
                pass
434
169
            else:
435
 
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
 
170
                self.assertNotContainsRe(help, 'From plugin "[^"]*"')
436
171
 
437
172
            if cmd_name in help_commands.keys():
438
173
                # some commands are hidden
439
174
                help = help_commands[cmd_name]
440
 
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
 
175
                self.assertNotContainsRe(help, 'From plugin "[^"]*"')
441
176
 
442
177
    def test_plugin_help_shows_plugin(self):
443
178
        # Create a test plugin
451
186
            bzrlib.plugin.load_from_path(['plugin_test'])
452
187
            bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
453
188
            help = self.run_bzr('help myplug')[0]
454
 
            self.assertContainsRe(help, 'plugin "myplug"')
 
189
            self.assertContainsRe(help, 'From plugin "myplug"')
455
190
            help = self.split_help_commands()['myplug']
456
191
            self.assertContainsRe(help, '\[myplug\]')
457
192
        finally:
458
193
            # unregister command
459
 
            if 'myplug' in bzrlib.commands.plugin_cmds:
460
 
                bzrlib.commands.plugin_cmds.remove('myplug')
 
194
            if bzrlib.commands.plugin_cmds.get('myplug', None):
 
195
                del bzrlib.commands.plugin_cmds['myplug']
461
196
            # remove the plugin 'myplug'
462
197
            if getattr(bzrlib.plugins, 'myplug', None):
463
198
                delattr(bzrlib.plugins, 'myplug')
464
199
 
465
200
 
 
201
class TestPluginFromZip(TestCaseInTempDir):
 
202
 
 
203
    def make_zipped_plugin(self, zip_name, filename):
 
204
        z = zipfile.ZipFile(zip_name, 'w')
 
205
        z.writestr(filename, PLUGIN_TEXT)
 
206
        z.close()
 
207
 
 
208
    def check_plugin_load(self, zip_name, plugin_name):
 
209
        self.assertFalse(plugin_name in dir(bzrlib.plugins),
 
210
                         'Plugin already loaded')
 
211
        old_path = bzrlib.plugins.__path__
 
212
        try:
 
213
            # this is normally done by load_plugins -> set_plugins_path
 
214
            bzrlib.plugins.__path__ = [zip_name]
 
215
            bzrlib.plugin.load_from_zip(zip_name)
 
216
            self.assertTrue(plugin_name in dir(bzrlib.plugins),
 
217
                            'Plugin is not loaded')
 
218
        finally:
 
219
            # unregister plugin
 
220
            if getattr(bzrlib.plugins, plugin_name, None):
 
221
                delattr(bzrlib.plugins, plugin_name)
 
222
                del sys.modules['bzrlib.plugins.' + plugin_name]
 
223
            bzrlib.plugins.__path__ = old_path
 
224
 
 
225
    def test_load_module(self):
 
226
        self.make_zipped_plugin('./test.zip', 'ziplug.py')
 
227
        self.check_plugin_load('./test.zip', 'ziplug')
 
228
 
 
229
    def test_load_package(self):
 
230
        self.make_zipped_plugin('./test.zip', 'ziplug/__init__.py')
 
231
        self.check_plugin_load('./test.zip', 'ziplug')
 
232
 
 
233
 
 
234
class TestSetPluginsPath(TestCase):
 
235
    
 
236
    def test_set_plugins_path(self):
 
237
        """set_plugins_path should set the module __path__ correctly."""
 
238
        old_path = bzrlib.plugins.__path__
 
239
        try:
 
240
            bzrlib.plugins.__path__ = []
 
241
            expected_path = bzrlib.plugin.set_plugins_path()
 
242
            self.assertEqual(expected_path, bzrlib.plugins.__path__)
 
243
        finally:
 
244
            bzrlib.plugins.__path__ = old_path
 
245
 
 
246
 
466
247
class TestHelpIndex(tests.TestCase):
467
248
    """Tests for the PluginsHelpIndex class."""
468
249
 
569
350
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
570
351
        topic = plugin.ModuleHelpTopic(mod)
571
352
        self.assertEqual('foo_bar', topic.get_help_topic())
572
 
 
573
 
 
574
 
class TestLoadFromPath(tests.TestCaseInTempDir):
575
 
 
576
 
    def setUp(self):
577
 
        super(TestLoadFromPath, self).setUp()
578
 
        # Change bzrlib.plugin to think no plugins have been loaded yet.
579
 
        self.overrideAttr(bzrlib.plugins, '__path__', [])
580
 
        self.overrideAttr(plugin, '_loaded', False)
581
 
 
582
 
        # Monkey-patch load_from_path to stop it from actually loading anything.
583
 
        self.overrideAttr(plugin, 'load_from_path', lambda dirs: None)
584
 
 
585
 
    def test_set_plugins_path_with_args(self):
586
 
        plugin.set_plugins_path(['a', 'b'])
587
 
        self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
588
 
 
589
 
    def test_set_plugins_path_defaults(self):
590
 
        plugin.set_plugins_path()
591
 
        self.assertEqual(plugin.get_standard_plugins_path(),
592
 
                         bzrlib.plugins.__path__)
593
 
 
594
 
    def test_get_standard_plugins_path(self):
595
 
        path = plugin.get_standard_plugins_path()
596
 
        for directory in path:
597
 
            self.assertNotContainsRe(directory, r'\\/$')
598
 
        try:
599
 
            from distutils.sysconfig import get_python_lib
600
 
        except ImportError:
601
 
            pass
602
 
        else:
603
 
            if sys.platform != 'win32':
604
 
                python_lib = get_python_lib()
605
 
                for directory in path:
606
 
                    if directory.startswith(python_lib):
607
 
                        break
608
 
                else:
609
 
                    self.fail('No path to global plugins')
610
 
 
611
 
    def test_get_standard_plugins_path_env(self):
612
 
        os.environ['BZR_PLUGIN_PATH'] = 'foo/'
613
 
        path = plugin.get_standard_plugins_path()
614
 
        for directory in path:
615
 
            self.assertNotContainsRe(directory, r'\\/$')
616
 
 
617
 
    def test_load_plugins(self):
618
 
        plugin.load_plugins(['.'])
619
 
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
620
 
        # subsequent loads are no-ops
621
 
        plugin.load_plugins(['foo'])
622
 
        self.assertEqual(bzrlib.plugins.__path__, ['.'])
623
 
 
624
 
    def test_load_plugins_default(self):
625
 
        plugin.load_plugins()
626
 
        path = plugin.get_standard_plugins_path()
627
 
        self.assertEqual(path, bzrlib.plugins.__path__)
628
 
 
629
 
 
630
 
class TestEnvPluginPath(tests.TestCaseInTempDir):
631
 
 
632
 
    def setUp(self):
633
 
        super(TestEnvPluginPath, self).setUp()
634
 
        self.overrideAttr(plugin, 'DEFAULT_PLUGIN_PATH', None)
635
 
 
636
 
        self.user = plugin.get_user_plugin_path()
637
 
        self.site = plugin.get_site_plugin_path()
638
 
        self.core = plugin.get_core_plugin_path()
639
 
 
640
 
    def _list2paths(self, *args):
641
 
        paths = []
642
 
        for p in args:
643
 
            plugin._append_new_path(paths, p)
644
 
        return paths
645
 
 
646
 
    def _set_path(self, *args):
647
 
        path = os.pathsep.join(self._list2paths(*args))
648
 
        osutils.set_or_unset_env('BZR_PLUGIN_PATH', path)
649
 
 
650
 
    def check_path(self, expected_dirs, setting_dirs):
651
 
        if setting_dirs:
652
 
            self._set_path(*setting_dirs)
653
 
        actual = plugin.get_standard_plugins_path()
654
 
        self.assertEquals(self._list2paths(*expected_dirs), actual)
655
 
 
656
 
    def test_default(self):
657
 
        self.check_path([self.user, self.core, self.site],
658
 
                        None)
659
 
 
660
 
    def test_adhoc_policy(self):
661
 
        self.check_path([self.user, self.core, self.site],
662
 
                        ['+user', '+core', '+site'])
663
 
 
664
 
    def test_fallback_policy(self):
665
 
        self.check_path([self.core, self.site, self.user],
666
 
                        ['+core', '+site', '+user'])
667
 
 
668
 
    def test_override_policy(self):
669
 
        self.check_path([self.user, self.site, self.core],
670
 
                        ['+user', '+site', '+core'])
671
 
 
672
 
    def test_disable_user(self):
673
 
        self.check_path([self.core, self.site], ['-user'])
674
 
 
675
 
    def test_disable_user_twice(self):
676
 
        # Ensures multiple removals don't left cruft
677
 
        self.check_path([self.core, self.site], ['-user', '-user'])
678
 
 
679
 
    def test_duplicates_are_removed(self):
680
 
        self.check_path([self.user, self.core, self.site],
681
 
                        ['+user', '+user'])
682
 
        # And only the first reference is kept (since the later references will
683
 
        # onnly produce <plugin> already loaded mutters)
684
 
        self.check_path([self.user, self.core, self.site],
685
 
                        ['+user', '+user', '+core',
686
 
                         '+user', '+site', '+site',
687
 
                         '+core'])
688
 
 
689
 
    def test_disable_overrides_disable(self):
690
 
        self.check_path([self.core, self.site], ['-user', '+user'])
691
 
 
692
 
    def test_disable_core(self):
693
 
        self.check_path([self.site], ['-core'])
694
 
        self.check_path([self.user, self.site], ['+user', '-core'])
695
 
 
696
 
    def test_disable_site(self):
697
 
        self.check_path([self.core], ['-site'])
698
 
        self.check_path([self.user, self.core], ['-site', '+user'])
699
 
 
700
 
    def test_override_site(self):
701
 
        self.check_path(['mysite', self.user, self.core],
702
 
                        ['mysite', '-site', '+user'])
703
 
        self.check_path(['mysite', self.core],
704
 
                        ['mysite', '-site'])
705
 
 
706
 
    def test_override_core(self):
707
 
        self.check_path(['mycore', self.user, self.site],
708
 
                        ['mycore', '-core', '+user', '+site'])
709
 
        self.check_path(['mycore', self.site],
710
 
                        ['mycore', '-core'])
711
 
 
712
 
    def test_my_plugin_only(self):
713
 
        self.check_path(['myplugin'], ['myplugin', '-user', '-core', '-site'])
714
 
 
715
 
    def test_my_plugin_first(self):
716
 
        self.check_path(['myplugin', self.core, self.site, self.user],
717
 
                        ['myplugin', '+core', '+site', '+user'])
718
 
 
719
 
    def test_bogus_references(self):
720
 
        self.check_path(['+foo', '-bar', self.core, self.site],
721
 
                        ['+foo', '-bar'])