1
# Copyright (C) 2005, 2007 Canonical Ltd
1
# Copyright (C) 2005 by Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
"""Tests for plugins"""
19
# XXX: There are no plugin tests at the moment because the plugin module
20
# affects the global state of the process. See bzrlib/plugins.py for more
25
from StringIO import StringIO
29
from bzrlib import plugin, tests
32
import bzrlib.commands
34
from bzrlib.symbol_versioning import one_three
35
from bzrlib.tests import (
40
from bzrlib.osutils import pathjoin, abspath, normpath
44
import bzrlib.commands
28
from bzrlib.selftest import InTempDir
31
def PluginTest(InTempDir):
32
"""Create an external plugin and test loading."""
36
orig_help = self.backtick('bzr help commands') # No plugins yet
37
os.mkdir('plugin_test')
38
f = open(os.path.join('plugin_test', 'myplug.py'), 'wt')
42
newhelp = backtick('bzr help commands')
43
assert newhelp.startswith('You have been overridden\n')
44
# We added a line, but the rest should work
45
assert newhelp[25:] == help
47
assert backtick('bzr commit -m test') == "I'm sorry dave, you can't do that\n"
49
shutil.rmtree('plugin_test')
55
"""import bzrlib, bzrlib.commands
45
56
class cmd_myplug(bzrlib.commands.Command):
46
57
'''Just a simple test plugin.'''
49
60
print 'Hello from my plugin'
52
# TODO: Write a test for plugin decoration of commands.
54
class TestLoadingPlugins(TestCaseInTempDir):
58
def test_plugins_with_the_same_name_are_not_loaded(self):
59
# This test tests that having two plugins in different directories does
60
# not result in both being loaded when they have the same name. get a
61
# file name we can use which is also a valid attribute for accessing in
62
# activeattributes. - we cannot give import parameters.
64
self.failIf(tempattribute in self.activeattributes)
65
# set a place for the plugins to record their loading, and at the same
66
# time validate that the location the plugins should record to is
68
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
70
self.failUnless(tempattribute in self.activeattributes)
71
# create two plugin directories
74
# write a plugin that will record when its loaded in the
76
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
77
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
79
outfile = open(os.path.join('first', 'plugin.py'), 'w')
81
outfile.write(template % (tempattribute, 'first'))
86
outfile = open(os.path.join('second', 'plugin.py'), 'w')
88
outfile.write(template % (tempattribute, 'second'))
94
bzrlib.plugin.load_from_path(['first', 'second'])
95
self.assertEqual(['first'], self.activeattributes[tempattribute])
97
# remove the plugin 'plugin'
98
del self.activeattributes[tempattribute]
99
if 'bzrlib.plugins.plugin' in sys.modules:
100
del sys.modules['bzrlib.plugins.plugin']
101
if getattr(bzrlib.plugins, 'plugin', None):
102
del bzrlib.plugins.plugin
103
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
105
def test_plugins_from_different_dirs_can_demand_load(self):
106
# This test tests that having two plugins in different
107
# directories with different names allows them both to be loaded, when
108
# we do a direct import statement.
109
# Determine a file name we can use which is also a valid attribute
110
# for accessing in activeattributes. - we cannot give import parameters.
111
tempattribute = "different-dirs"
112
self.failIf(tempattribute in self.activeattributes)
113
# set a place for the plugins to record their loading, and at the same
114
# time validate that the location the plugins should record to is
116
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
118
self.failUnless(tempattribute in self.activeattributes)
119
# create two plugin directories
122
# write plugins that will record when they are loaded in the
123
# tempattribute list.
124
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
125
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
127
outfile = open(os.path.join('first', 'pluginone.py'), 'w')
129
outfile.write(template % (tempattribute, 'first'))
134
outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
136
outfile.write(template % (tempattribute, 'second'))
141
oldpath = bzrlib.plugins.__path__
143
bzrlib.plugins.__path__ = ['first', 'second']
144
exec "import bzrlib.plugins.pluginone"
145
self.assertEqual(['first'], self.activeattributes[tempattribute])
146
exec "import bzrlib.plugins.plugintwo"
147
self.assertEqual(['first', 'second'],
148
self.activeattributes[tempattribute])
150
# remove the plugin 'plugin'
151
del self.activeattributes[tempattribute]
152
if getattr(bzrlib.plugins, 'pluginone', None):
153
del bzrlib.plugins.pluginone
154
if getattr(bzrlib.plugins, 'plugintwo', None):
155
del bzrlib.plugins.plugintwo
156
self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
157
self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
159
def test_plugins_can_load_from_directory_with_trailing_slash(self):
160
# This test tests that a plugin can load from a directory when the
161
# directory in the path has a trailing slash.
162
# check the plugin is not loaded already
163
self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
164
tempattribute = "trailing-slash"
165
self.failIf(tempattribute in self.activeattributes)
166
# set a place for the plugin to record its loading, and at the same
167
# time validate that the location the plugin should record to is
169
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
171
self.failUnless(tempattribute in self.activeattributes)
172
# create a directory for the plugin
173
os.mkdir('plugin_test')
174
# write a plugin that will record when its loaded in the
175
# tempattribute list.
176
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
177
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
179
outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
181
outfile.write(template % (tempattribute, 'plugin'))
187
bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
188
self.assertEqual(['plugin'], self.activeattributes[tempattribute])
190
# remove the plugin 'plugin'
191
del self.activeattributes[tempattribute]
192
if getattr(bzrlib.plugins, 'ts_plugin', None):
193
del bzrlib.plugins.ts_plugin
194
self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
196
def load_and_capture(self, name):
197
"""Load plugins from '.' capturing the output.
199
:param name: The name of the plugin.
200
:return: A string with the log from the plugin loading call.
205
handler = logging.StreamHandler(stream)
206
log = logging.getLogger('bzr')
207
log.addHandler(handler)
210
bzrlib.plugin.load_from_path(['.'])
212
if 'bzrlib.plugins.%s' % name in sys.modules:
213
del sys.modules['bzrlib.plugins.%s' % name]
214
if getattr(bzrlib.plugins, name, None):
215
delattr(bzrlib.plugins, name)
217
# Stop capturing output
220
log.removeHandler(handler)
221
return stream.getvalue()
225
def test_plugin_with_bad_api_version_reports(self):
226
# This plugin asks for bzrlib api version 1.0.0, which is not supported
231
f.write("import bzrlib.api\n"
232
"bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
236
log = self.load_and_capture(name)
237
self.assertContainsRe(log,
238
r"It requested API version")
240
def test_plugin_with_bad_name_does_not_load(self):
241
# The file name here invalid for a python module.
242
name = 'bzr-bad plugin-name..py'
243
file(name, 'w').close()
244
log = self.load_and_capture(name)
245
self.assertContainsRe(log,
246
r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
247
"because the file path isn't a valid module name; try renaming "
248
"it to 'bad_plugin_name_'\.")
251
class TestPlugins(TestCaseInTempDir):
253
def setup_plugin(self, source=""):
254
# This test tests a new plugin appears in bzrlib.plugin.plugins().
255
# check the plugin is not loaded already
256
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
257
# write a plugin that _cannot_ fail to load.
258
file('plugin.py', 'w').write(source + '\n')
259
self.addCleanup(self.teardown_plugin)
260
bzrlib.plugin.load_from_path(['.'])
262
def teardown_plugin(self):
263
# remove the plugin 'plugin'
264
if 'bzrlib.plugins.plugin' in sys.modules:
265
del sys.modules['bzrlib.plugins.plugin']
266
if getattr(bzrlib.plugins, 'plugin', None):
267
del bzrlib.plugins.plugin
268
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
270
def test_plugin_appears_in_plugins(self):
272
self.failUnless('plugin' in bzrlib.plugin.plugins())
273
self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
274
plugins = bzrlib.plugin.plugins()
275
plugin = plugins['plugin']
276
self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
277
self.assertEqual(bzrlib.plugins.plugin, plugin.module)
279
def test_trivial_plugin_get_path(self):
281
plugins = bzrlib.plugin.plugins()
282
plugin = plugins['plugin']
283
plugin_path = self.test_dir + '/plugin.py'
284
self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
286
def test_plugin_get_path_py_not_pyc(self):
287
self.setup_plugin() # after first import there will be plugin.pyc
288
self.teardown_plugin()
289
bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
290
plugins = bzrlib.plugin.plugins()
291
plugin = plugins['plugin']
292
plugin_path = self.test_dir + '/plugin.py'
293
self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
295
def test_plugin_get_path_pyc_only(self):
296
self.setup_plugin() # after first import there will be plugin.pyc
297
self.teardown_plugin()
298
os.unlink(self.test_dir + '/plugin.py')
299
bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
300
plugins = bzrlib.plugin.plugins()
301
plugin = plugins['plugin']
303
plugin_path = self.test_dir + '/plugin.pyc'
305
plugin_path = self.test_dir + '/plugin.pyo'
306
self.assertIsSameRealPath(plugin_path, normpath(plugin.path()))
308
def test_no_test_suite_gives_None_for_test_suite(self):
310
plugin = bzrlib.plugin.plugins()['plugin']
311
self.assertEqual(None, plugin.test_suite())
313
def test_test_suite_gives_test_suite_result(self):
314
source = """def test_suite(): return 'foo'"""
315
self.setup_plugin(source)
316
plugin = bzrlib.plugin.plugins()['plugin']
317
self.assertEqual('foo', plugin.test_suite())
319
def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
321
loader = TestUtil.TestLoader()
322
plugin = bzrlib.plugin.plugins()['plugin']
323
self.assertEqual(None, plugin.load_plugin_tests(loader))
325
def test_load_plugin_tests_gives_load_plugin_tests_result(self):
327
def load_tests(standard_tests, module, loader):
329
self.setup_plugin(source)
330
loader = TestUtil.TestLoader()
331
plugin = bzrlib.plugin.plugins()['plugin']
332
self.assertEqual('foo', plugin.load_plugin_tests(loader))
334
def test_no_version_info(self):
336
plugin = bzrlib.plugin.plugins()['plugin']
337
self.assertEqual(None, plugin.version_info())
339
def test_with_version_info(self):
340
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
341
plugin = bzrlib.plugin.plugins()['plugin']
342
self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
344
def test_short_version_info_gets_padded(self):
345
# the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
347
self.setup_plugin("version_info = (1, 2, 3)")
348
plugin = bzrlib.plugin.plugins()['plugin']
349
self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
351
def test_no_version_info___version__(self):
353
plugin = bzrlib.plugin.plugins()['plugin']
354
self.assertEqual("unknown", plugin.__version__)
356
def test_str__version__with_version_info(self):
357
self.setup_plugin("version_info = '1.2.3'")
358
plugin = bzrlib.plugin.plugins()['plugin']
359
self.assertEqual("1.2.3", plugin.__version__)
361
def test_noniterable__version__with_version_info(self):
362
self.setup_plugin("version_info = (1)")
363
plugin = bzrlib.plugin.plugins()['plugin']
364
self.assertEqual("1", plugin.__version__)
366
def test_1__version__with_version_info(self):
367
self.setup_plugin("version_info = (1,)")
368
plugin = bzrlib.plugin.plugins()['plugin']
369
self.assertEqual("1", plugin.__version__)
371
def test_1_2__version__with_version_info(self):
372
self.setup_plugin("version_info = (1, 2)")
373
plugin = bzrlib.plugin.plugins()['plugin']
374
self.assertEqual("1.2", plugin.__version__)
376
def test_1_2_3__version__with_version_info(self):
377
self.setup_plugin("version_info = (1, 2, 3)")
378
plugin = bzrlib.plugin.plugins()['plugin']
379
self.assertEqual("1.2.3", plugin.__version__)
381
def test_candidate__version__with_version_info(self):
382
self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
383
plugin = bzrlib.plugin.plugins()['plugin']
384
self.assertEqual("1.2.3rc1", plugin.__version__)
386
def test_dev__version__with_version_info(self):
387
self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
388
plugin = bzrlib.plugin.plugins()['plugin']
389
self.assertEqual("1.2.3dev", plugin.__version__)
391
def test_dev_fallback__version__with_version_info(self):
392
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
393
plugin = bzrlib.plugin.plugins()['plugin']
394
self.assertEqual("1.2.3.dev.4", plugin.__version__)
396
def test_final__version__with_version_info(self):
397
self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
398
plugin = bzrlib.plugin.plugins()['plugin']
399
self.assertEqual("1.2.3", plugin.__version__)
402
class TestPluginHelp(TestCaseInTempDir):
404
def split_help_commands(self):
407
out, err = self.run_bzr('--no-plugins help commands')
408
for line in out.splitlines():
409
if not line.startswith(' '):
410
current = line.split()[0]
411
help[current] = help.get(current, '') + line
415
def test_plugin_help_builtins_unaffected(self):
416
# Check we don't get false positives
417
help_commands = self.split_help_commands()
418
for cmd_name in bzrlib.commands.builtin_command_names():
419
if cmd_name in bzrlib.commands.plugin_command_names():
422
help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
423
except NotImplementedError:
424
# some commands have no help
427
self.assertNotContainsRe(help, 'plugin "[^"]*"')
429
if cmd_name in help_commands.keys():
430
# some commands are hidden
431
help = help_commands[cmd_name]
432
self.assertNotContainsRe(help, 'plugin "[^"]*"')
434
def test_plugin_help_shows_plugin(self):
435
# Create a test plugin
436
os.mkdir('plugin_test')
437
f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
443
bzrlib.plugin.load_from_path(['plugin_test'])
444
bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
445
help = self.run_bzr('help myplug')[0]
446
self.assertContainsRe(help, 'plugin "myplug"')
447
help = self.split_help_commands()['myplug']
448
self.assertContainsRe(help, '\[myplug\]')
451
if 'myplug' in bzrlib.commands.plugin_cmds:
452
bzrlib.commands.plugin_cmds.remove('myplug')
453
# remove the plugin 'myplug'
454
if getattr(bzrlib.plugins, 'myplug', None):
455
delattr(bzrlib.plugins, 'myplug')
458
class TestPluginFromZip(TestCaseInTempDir):
460
def make_zipped_plugin(self, zip_name, filename):
461
z = zipfile.ZipFile(zip_name, 'w')
462
z.writestr(filename, PLUGIN_TEXT)
465
def check_plugin_load(self, zip_name, plugin_name):
466
self.assertFalse(plugin_name in dir(bzrlib.plugins),
467
'Plugin already loaded')
468
old_path = bzrlib.plugins.__path__
470
# this is normally done by load_plugins -> set_plugins_path
471
bzrlib.plugins.__path__ = [zip_name]
472
self.applyDeprecated(one_three,
473
bzrlib.plugin.load_from_zip, zip_name)
474
self.assertTrue(plugin_name in dir(bzrlib.plugins),
475
'Plugin is not loaded')
478
if getattr(bzrlib.plugins, plugin_name, None):
479
delattr(bzrlib.plugins, plugin_name)
480
del sys.modules['bzrlib.plugins.' + plugin_name]
481
bzrlib.plugins.__path__ = old_path
483
def test_load_module(self):
484
self.make_zipped_plugin('./test.zip', 'ziplug.py')
485
self.check_plugin_load('./test.zip', 'ziplug')
487
def test_load_package(self):
488
self.make_zipped_plugin('./test.zip', 'ziplug/__init__.py')
489
self.check_plugin_load('./test.zip', 'ziplug')
492
class TestSetPluginsPath(TestCase):
494
def test_set_plugins_path(self):
495
"""set_plugins_path should set the module __path__ correctly."""
496
old_path = bzrlib.plugins.__path__
498
bzrlib.plugins.__path__ = []
499
expected_path = bzrlib.plugin.set_plugins_path()
500
self.assertEqual(expected_path, bzrlib.plugins.__path__)
502
bzrlib.plugins.__path__ = old_path
504
def test_set_plugins_path_with_trailing_slashes(self):
505
"""set_plugins_path should set the module __path__ based on
506
BZR_PLUGIN_PATH after removing all trailing slashes."""
507
old_path = bzrlib.plugins.__path__
508
old_env = os.environ.get('BZR_PLUGIN_PATH')
510
bzrlib.plugins.__path__ = []
511
os.environ['BZR_PLUGIN_PATH'] = "first\\//\\" + os.pathsep + \
513
bzrlib.plugin.set_plugins_path()
514
# We expect our nominated paths to have all path-seps removed,
515
# and this is testing only that.
516
expected_path = ['first', 'second']
517
self.assertEqual(expected_path,
518
bzrlib.plugins.__path__[:len(expected_path)])
520
bzrlib.plugins.__path__ = old_path
521
if old_env is not None:
522
os.environ['BZR_PLUGIN_PATH'] = old_env
524
del os.environ['BZR_PLUGIN_PATH']
527
class TestHelpIndex(tests.TestCase):
528
"""Tests for the PluginsHelpIndex class."""
530
def test_default_constructable(self):
531
index = plugin.PluginsHelpIndex()
533
def test_get_topics_None(self):
534
"""Searching for None returns an empty list."""
535
index = plugin.PluginsHelpIndex()
536
self.assertEqual([], index.get_topics(None))
538
def test_get_topics_for_plugin(self):
539
"""Searching for plugin name gets its docstring."""
540
index = plugin.PluginsHelpIndex()
541
# make a new plugin here for this test, even if we're run with
543
self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
544
demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
545
sys.modules['bzrlib.plugins.demo_module'] = demo_module
547
topics = index.get_topics('demo_module')
548
self.assertEqual(1, len(topics))
549
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
550
self.assertEqual(demo_module, topics[0].module)
552
del sys.modules['bzrlib.plugins.demo_module']
554
def test_get_topics_no_topic(self):
555
"""Searching for something that is not a plugin returns []."""
556
# test this by using a name that cannot be a plugin - its not
557
# a valid python identifier.
558
index = plugin.PluginsHelpIndex()
559
self.assertEqual([], index.get_topics('nothing by this name'))
561
def test_prefix(self):
562
"""PluginsHelpIndex has a prefix of 'plugins/'."""
563
index = plugin.PluginsHelpIndex()
564
self.assertEqual('plugins/', index.prefix)
566
def test_get_plugin_topic_with_prefix(self):
567
"""Searching for plugins/demo_module returns help."""
568
index = plugin.PluginsHelpIndex()
569
self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
570
demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
571
sys.modules['bzrlib.plugins.demo_module'] = demo_module
573
topics = index.get_topics('plugins/demo_module')
574
self.assertEqual(1, len(topics))
575
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
576
self.assertEqual(demo_module, topics[0].module)
578
del sys.modules['bzrlib.plugins.demo_module']
581
class FakeModule(object):
582
"""A fake module to test with."""
584
def __init__(self, doc, name):
589
class TestModuleHelpTopic(tests.TestCase):
590
"""Tests for the ModuleHelpTopic class."""
592
def test_contruct(self):
593
"""Construction takes the module to document."""
594
mod = FakeModule('foo', 'foo')
595
topic = plugin.ModuleHelpTopic(mod)
596
self.assertEqual(mod, topic.module)
598
def test_get_help_text_None(self):
599
"""A ModuleHelpTopic returns the docstring for get_help_text."""
600
mod = FakeModule(None, 'demo')
601
topic = plugin.ModuleHelpTopic(mod)
602
self.assertEqual("Plugin 'demo' has no docstring.\n",
603
topic.get_help_text())
605
def test_get_help_text_no_carriage_return(self):
606
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
607
mod = FakeModule('one line of help', 'demo')
608
topic = plugin.ModuleHelpTopic(mod)
609
self.assertEqual("one line of help\n",
610
topic.get_help_text())
612
def test_get_help_text_carriage_return(self):
613
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
614
mod = FakeModule('two lines of help\nand more\n', 'demo')
615
topic = plugin.ModuleHelpTopic(mod)
616
self.assertEqual("two lines of help\nand more\n",
617
topic.get_help_text())
619
def test_get_help_text_with_additional_see_also(self):
620
mod = FakeModule('two lines of help\nand more', 'demo')
621
topic = plugin.ModuleHelpTopic(mod)
622
self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
623
topic.get_help_text(['foo', 'bar']))
625
def test_get_help_topic(self):
626
"""The help topic for a plugin is its module name."""
627
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
628
topic = plugin.ModuleHelpTopic(mod)
629
self.assertEqual('demo', topic.get_help_topic())
630
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
631
topic = plugin.ModuleHelpTopic(mod)
632
self.assertEqual('foo_bar', topic.get_help_topic())
635
def clear_plugins(test_case):
636
# Save the attributes that we're about to monkey-patch.
637
old_plugins_path = bzrlib.plugins.__path__
638
old_loaded = plugin._loaded
639
old_load_from_path = plugin.load_from_path
640
# Change bzrlib.plugin to think no plugins have been loaded yet.
641
bzrlib.plugins.__path__ = []
642
plugin._loaded = False
643
# Monkey-patch load_from_path to stop it from actually loading anything.
644
def load_from_path(dirs):
646
plugin.load_from_path = load_from_path
647
def restore_plugins():
648
bzrlib.plugins.__path__ = old_plugins_path
649
plugin._loaded = old_loaded
650
plugin.load_from_path = old_load_from_path
651
test_case.addCleanup(restore_plugins)
654
class TestPluginPaths(tests.TestCase):
656
def test_set_plugins_path_with_args(self):
658
plugin.set_plugins_path(['a', 'b'])
659
self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
661
def test_set_plugins_path_defaults(self):
663
plugin.set_plugins_path()
664
self.assertEqual(plugin.get_standard_plugins_path(),
665
bzrlib.plugins.__path__)
667
def test_get_standard_plugins_path(self):
668
path = plugin.get_standard_plugins_path()
669
self.assertEqual(plugin.get_default_plugin_path(), path[0])
670
for directory in path:
671
self.assertNotContainsRe(r'\\/$', directory)
673
from distutils.sysconfig import get_python_lib
677
if sys.platform != 'win32':
678
python_lib = get_python_lib()
679
for directory in path:
680
if directory.startswith(python_lib):
683
self.fail('No path to global plugins')
685
def test_get_standard_plugins_path_env(self):
686
os.environ['BZR_PLUGIN_PATH'] = 'foo/'
687
self.assertEqual('foo', plugin.get_standard_plugins_path()[0])
690
class TestLoadPlugins(tests.TestCaseInTempDir):
692
def test_load_plugins(self):
694
plugin.load_plugins(['.'])
695
self.assertEqual(bzrlib.plugins.__path__, ['.'])
696
# subsequent loads are no-ops
697
plugin.load_plugins(['foo'])
698
self.assertEqual(bzrlib.plugins.__path__, ['.'])
700
def test_load_plugins_default(self):
702
plugin.load_plugins()
703
path = plugin.get_standard_plugins_path()
704
self.assertEqual(path, bzrlib.plugins.__path__)
64
os.environ['BZRPLUGINPATH'] = os.path.abspath('plugin_test')
65
help = backtick('bzr help commands')
66
assert help.find('myplug') != -1
67
assert help.find('Just a simple test plugin.') != -1
70
assert backtick('bzr myplug') == 'Hello from my plugin\n'
71
assert backtick('bzr mplg') == 'Hello from my plugin\n'
73
f = open(os.path.join('plugin_test', 'override.py'), 'wb')
74
f.write("""import bzrlib, bzrlib.commands
75
class cmd_commit(bzrlib.commands.cmd_commit):
76
'''Commit changes into a new revision.'''
77
def run(self, *args, **kwargs):
78
print "I'm sorry dave, you can't do that"
80
class cmd_help(bzrlib.commands.cmd_help):
81
'''Show help on a command or other topic.'''
82
def run(self, *args, **kwargs):
83
print "You have been overridden"
84
bzrlib.commands.cmd_help.run(self, *args, **kwargs)
added
removed
bzrlib/selftest/plugins.py
