20
21
# affects the global state of the process. See bzrlib/plugins.py for more
23
from cStringIO import StringIO
25
from StringIO import StringIO
29
import bzrlib.commands
31
from bzrlib.tests import TestCaseInTempDir
32
from bzrlib.osutils import pathjoin, abspath
34
class PluginTest(TestCaseInTempDir):
35
"""Create an external plugin and test loading."""
36
# def test_plugin_loading(self):
37
# orig_help = self.run_bzr_captured('bzr help commands')[0]
38
# os.mkdir('plugin_test')
39
# f = open(pathjoin('plugin_test', 'myplug.py'), 'wt')
40
# f.write(PLUGIN_TEXT)
42
# newhelp = self.run_bzr_captured('bzr help commands')[0]
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')
52
# os.environ['BZRPLUGINPATH'] = abspath('plugin_test')
53
# help = backtick('bzr help commands')
54
# assert help.find('myplug') != -1
55
# assert help.find('Just a simple test plugin.') != -1
58
# assert backtick('bzr myplug') == 'Hello from my plugin\n'
59
# assert backtick('bzr mplg') == 'Hello from my plugin\n'
61
# f = open(pathjoin('plugin_test', 'override.py'), 'wb')
62
# f.write("""import bzrlib, bzrlib.commands
63
# class cmd_commit(bzrlib.commands.cmd_commit):
64
# '''Commit changes into a new revision.'''
65
# def run(self, *args, **kwargs):
66
# print "I'm sorry dave, you can't do that"
68
# class cmd_help(bzrlib.commands.cmd_help):
69
# '''Show help on a command or other topic.'''
70
# def run(self, *args, **kwargs):
71
# print "You have been overridden"
72
# bzrlib.commands.cmd_help.run(self, *args, **kwargs)
77
import bzrlib.commands
78
class cmd_myplug(bzrlib.commands.Command):
79
'''Just a simple test plugin.'''
82
print 'Hello from my plugin'
38
85
# TODO: Write a test for plugin decoration of commands.
40
class TestPluginMixin(object):
42
def create_plugin(self, name, source=None, dir='.', file_name=None):
45
"""This is the doc for %s"""
48
file_name = name + '.py'
49
# 'source' must not fail to load
50
path = osutils.pathjoin(dir, file_name)
52
self.addCleanup(os.unlink, path)
54
f.write(source + '\n')
58
def create_plugin_package(self, name, dir=None, source=None):
63
"""This is the doc for %s"""
68
# Workaround lazy import random? madness
70
self.addCleanup(cleanup)
71
self.create_plugin(name, source, dir,
72
file_name='__init__.py')
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)
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)
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)
91
class TestLoadingPlugins(tests.TestCaseInTempDir, TestPluginMixin):
87
class TestOneNamedPluginOnly(TestCaseInTempDir):
93
89
activeattributes = {}
95
91
def test_plugins_with_the_same_name_are_not_loaded(self):
96
# This test tests that having two plugins in different directories does
97
# not result in both being loaded when they have the same name. get a
98
# file name we can use which is also a valid attribute for accessing in
99
# activeattributes. - we cannot give import parameters.
101
self.failIf(tempattribute in self.activeattributes)
102
# set a place for the plugins to record their loading, and at the same
103
# time validate that the location the plugins should record to is
105
self.__class__.activeattributes [tempattribute] = []
106
self.failUnless(tempattribute in self.activeattributes)
107
# create two plugin directories
110
# write a plugin that will record when its loaded in the
111
# tempattribute list.
112
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
113
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
115
outfile = open(os.path.join('first', 'plugin.py'), 'w')
117
outfile.write(template % (tempattribute, 'first'))
122
outfile = open(os.path.join('second', 'plugin.py'), 'w')
124
outfile.write(template % (tempattribute, 'second'))
130
bzrlib.plugin.load_from_path(['first', 'second'])
131
self.assertEqual(['first'], self.activeattributes[tempattribute])
133
# remove the plugin 'plugin'
134
del self.activeattributes[tempattribute]
135
self._unregister_plugin('plugin')
136
self.assertPluginUnknown('plugin')
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)
141
92
# This test tests that having two plugins in different
142
# directories with different names allows them both to be loaded, when
143
# we do a direct import statement.
144
# Determine a file name we can use which is also a valid attribute
93
# directories does not result in both being loaded.
94
# get a file name we can use which is also a valid attribute
145
95
# for accessing in activeattributes. - we cannot give import parameters.
146
tempattribute = "different-dirs"
147
97
self.failIf(tempattribute in self.activeattributes)
148
98
# set a place for the plugins to record their loading, and at the same
149
99
# time validate that the location the plugins should record to is
150
100
# valid and correct.
151
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
101
bzrlib.tests.test_plugins.TestOneNamedPluginOnly.activeattributes \
152
102
[tempattribute] = []
153
103
self.failUnless(tempattribute in self.activeattributes)
154
104
# create two plugin directories
155
105
os.mkdir('first')
156
106
os.mkdir('second')
157
# write plugins that will record when they are loaded in the
107
# write a plugin that will record when its loaded in the
158
108
# tempattribute list.
159
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
160
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
162
outfile = open(os.path.join('first', 'pluginone.py'), 'w')
164
outfile.write(template % (tempattribute, 'first'))
169
outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
171
outfile.write(template % (tempattribute, 'second'))
176
oldpath = bzrlib.plugins.__path__
178
self.failIf('bzrlib.plugins.pluginone' in sys.modules)
179
self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
180
bzrlib.plugins.__path__ = ['first', 'second']
181
exec "import bzrlib.plugins.pluginone"
109
template = ("from bzrlib.tests.test_plugins import TestOneNamedPluginOnly\n"
110
"TestOneNamedPluginOnly.activeattributes[%r].append('%s')\n")
111
print >> file(os.path.join('first', 'plugin.py'), 'w'), template % (tempattribute, 'first')
112
print >> file(os.path.join('second', 'plugin.py'), 'w'), template % (tempattribute, 'second')
114
bzrlib.plugin.load_from_dirs(['first', 'second'])
182
115
self.assertEqual(['first'], self.activeattributes[tempattribute])
183
exec "import bzrlib.plugins.plugintwo"
184
self.assertEqual(['first', 'second'],
185
self.activeattributes[tempattribute])
187
117
# remove the plugin 'plugin'
188
118
del self.activeattributes[tempattribute]
189
self._unregister_plugin('pluginone')
190
self._unregister_plugin('plugintwo')
191
self.assertPluginUnknown('pluginone')
192
self.assertPluginUnknown('plugintwo')
194
def test_plugins_can_load_from_directory_with_trailing_slash(self):
195
# This test tests that a plugin can load from a directory when the
196
# directory in the path has a trailing slash.
197
# check the plugin is not loaded already
198
self.assertPluginUnknown('ts_plugin')
199
tempattribute = "trailing-slash"
200
self.failIf(tempattribute in self.activeattributes)
201
# set a place for the plugin to record its loading, and at the same
202
# time validate that the location the plugin should record to is
204
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
206
self.failUnless(tempattribute in self.activeattributes)
207
# create a directory for the plugin
208
os.mkdir('plugin_test')
209
# write a plugin that will record when its loaded in the
210
# tempattribute list.
211
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
212
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
214
outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
216
outfile.write(template % (tempattribute, 'plugin'))
222
bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
223
self.assertEqual(['plugin'], self.activeattributes[tempattribute])
225
del self.activeattributes[tempattribute]
226
self._unregister_plugin('ts_plugin')
227
self.assertPluginUnknown('ts_plugin')
229
def load_and_capture(self, name):
230
"""Load plugins from '.' capturing the output.
232
:param name: The name of the plugin.
233
:return: A string with the log from the plugin loading call.
238
handler = logging.StreamHandler(stream)
239
log = logging.getLogger('bzr')
240
log.addHandler(handler)
243
bzrlib.plugin.load_from_path(['.'])
245
if 'bzrlib.plugins.%s' % name in sys.modules:
246
del sys.modules['bzrlib.plugins.%s' % name]
247
if getattr(bzrlib.plugins, name, None):
248
delattr(bzrlib.plugins, name)
250
# Stop capturing output
253
log.removeHandler(handler)
254
return stream.getvalue()
258
def test_plugin_with_bad_api_version_reports(self):
259
# This plugin asks for bzrlib api version 1.0.0, which is not supported
264
f.write("import bzrlib.api\n"
265
"bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
269
log = self.load_and_capture(name)
270
self.assertContainsRe(log,
271
r"It requested API version")
273
def test_plugin_with_bad_name_does_not_load(self):
274
# The file name here invalid for a python module.
275
name = 'bzr-bad plugin-name..py'
276
file(name, 'w').close()
277
log = self.load_and_capture(name)
278
self.assertContainsRe(log,
279
r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
280
"because the file path isn't a valid module name; try renaming "
281
"it to 'bad_plugin_name_'\.")
284
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
286
def setup_plugin(self, source=""):
287
# This test tests a new plugin appears in bzrlib.plugin.plugins().
288
# check the plugin is not loaded already
289
self.assertPluginUnknown('plugin')
119
if getattr(bzrlib.plugins, 'plugin', None):
120
del bzrlib.plugins.plugin
121
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
124
class TestAllPlugins(TestCaseInTempDir):
126
def test_plugin_appears_in_all_plugins(self):
127
# This test tests a new plugin appears in bzrlib.plugin.all_plugins().
128
# check the plugin is not loaded already
129
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
290
130
# write a plugin that _cannot_ fail to load.
291
file('plugin.py', 'w').write(source + '\n')
292
self.addCleanup(self.teardown_plugin)
293
plugin.load_from_path(['.'])
295
def teardown_plugin(self):
296
self._unregister_plugin('plugin')
297
self.assertPluginUnknown('plugin')
299
def test_plugin_appears_in_plugins(self):
301
self.assertPluginKnown('plugin')
302
p = plugin.plugins()['plugin']
303
self.assertIsInstance(p, bzrlib.plugin.PlugIn)
304
self.assertEqual(p.module, plugins.plugin)
306
def test_trivial_plugin_get_path(self):
308
p = plugin.plugins()['plugin']
309
plugin_path = self.test_dir + '/plugin.py'
310
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
312
def test_plugin_get_path_py_not_pyc(self):
313
# first import creates plugin.pyc
315
self.teardown_plugin()
316
plugin.load_from_path(['.']) # import plugin.pyc
317
p = plugin.plugins()['plugin']
318
plugin_path = self.test_dir + '/plugin.py'
319
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
321
def test_plugin_get_path_pyc_only(self):
322
# first import creates plugin.pyc (or plugin.pyo depending on __debug__)
324
self.teardown_plugin()
325
os.unlink(self.test_dir + '/plugin.py')
326
plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
327
p = plugin.plugins()['plugin']
329
plugin_path = self.test_dir + '/plugin.pyc'
331
plugin_path = self.test_dir + '/plugin.pyo'
332
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
334
def test_no_test_suite_gives_None_for_test_suite(self):
336
p = plugin.plugins()['plugin']
337
self.assertEqual(None, p.test_suite())
339
def test_test_suite_gives_test_suite_result(self):
340
source = """def test_suite(): return 'foo'"""
341
self.setup_plugin(source)
342
p = plugin.plugins()['plugin']
343
self.assertEqual('foo', p.test_suite())
345
def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
347
loader = tests.TestUtil.TestLoader()
348
p = plugin.plugins()['plugin']
349
self.assertEqual(None, p.load_plugin_tests(loader))
351
def test_load_plugin_tests_gives_load_plugin_tests_result(self):
353
def load_tests(standard_tests, module, loader):
355
self.setup_plugin(source)
356
loader = tests.TestUtil.TestLoader()
357
p = plugin.plugins()['plugin']
358
self.assertEqual('foo', p.load_plugin_tests(loader))
360
def check_version_info(self, expected, source='', name='plugin'):
361
self.setup_plugin(source)
362
self.assertEqual(expected, plugin.plugins()[name].version_info())
364
def test_no_version_info(self):
365
self.check_version_info(None)
367
def test_with_version_info(self):
368
self.check_version_info((1, 2, 3, 'dev', 4),
369
"version_info = (1, 2, 3, 'dev', 4)")
371
def test_short_version_info_gets_padded(self):
372
# the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
374
self.check_version_info((1, 2, 3, 'final', 0),
375
"version_info = (1, 2, 3)")
377
def check_version(self, expected, source=None, name='plugin'):
378
self.setup_plugin(source)
379
self.assertEqual(expected, plugins[name].__version__)
381
def test_no_version_info___version__(self):
383
plugin = bzrlib.plugin.plugins()['plugin']
384
self.assertEqual("unknown", plugin.__version__)
386
def test_str__version__with_version_info(self):
387
self.setup_plugin("version_info = '1.2.3'")
388
plugin = bzrlib.plugin.plugins()['plugin']
389
self.assertEqual("1.2.3", plugin.__version__)
391
def test_noniterable__version__with_version_info(self):
392
self.setup_plugin("version_info = (1)")
393
plugin = bzrlib.plugin.plugins()['plugin']
394
self.assertEqual("1", plugin.__version__)
396
def test_1__version__with_version_info(self):
397
self.setup_plugin("version_info = (1,)")
398
plugin = bzrlib.plugin.plugins()['plugin']
399
self.assertEqual("1", plugin.__version__)
401
def test_1_2__version__with_version_info(self):
402
self.setup_plugin("version_info = (1, 2)")
403
plugin = bzrlib.plugin.plugins()['plugin']
404
self.assertEqual("1.2", plugin.__version__)
406
def test_1_2_3__version__with_version_info(self):
407
self.setup_plugin("version_info = (1, 2, 3)")
408
plugin = bzrlib.plugin.plugins()['plugin']
409
self.assertEqual("1.2.3", plugin.__version__)
411
def test_candidate__version__with_version_info(self):
412
self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
413
plugin = bzrlib.plugin.plugins()['plugin']
414
self.assertEqual("1.2.3rc1", plugin.__version__)
416
def test_dev__version__with_version_info(self):
417
self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
418
plugin = bzrlib.plugin.plugins()['plugin']
419
self.assertEqual("1.2.3dev", plugin.__version__)
421
def test_dev_fallback__version__with_version_info(self):
422
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
423
plugin = bzrlib.plugin.plugins()['plugin']
424
self.assertEqual("1.2.3dev4", plugin.__version__)
426
def test_final__version__with_version_info(self):
427
self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
428
plugin = bzrlib.plugin.plugins()['plugin']
429
self.assertEqual("1.2.3", plugin.__version__)
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__)
437
class TestPluginHelp(tests.TestCaseInTempDir):
131
print >> file('plugin.py', 'w'), ""
133
bzrlib.plugin.load_from_dirs(['.'])
134
self.failUnless('plugin' in bzrlib.plugin.all_plugins())
135
self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
136
self.assertEqual(bzrlib.plugin.all_plugins()['plugin'],
137
bzrlib.plugins.plugin)
139
# remove the plugin 'plugin'
140
if getattr(bzrlib.plugins, 'plugin', None):
141
del bzrlib.plugins.plugin
142
self.failIf(getattr(bzrlib.plugins, 'plugin', None))
145
class TestPluginHelp(TestCaseInTempDir):
439
147
def split_help_commands(self):
442
out, err = self.run_bzr('--no-plugins help commands')
443
for line in out.splitlines():
444
if not line.startswith(' '):
445
current = line.split()[0]
150
for line in self.capture('help commands').splitlines():
151
if line.startswith('bzr '):
152
current = line.split()[1]
446
153
help[current] = help.get(current, '') + line
453
160
for cmd_name in bzrlib.commands.builtin_command_names():
454
161
if cmd_name in bzrlib.commands.plugin_command_names():
457
help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
165
bzrlib.help.help_on_command(cmd_name, help)
458
166
except NotImplementedError:
459
167
# some commands have no help
462
self.assertNotContainsRe(help, 'plugin "[^"]*"')
171
self.assertNotContainsRe(help.read(), 'From plugin "[^"]*"')
464
if cmd_name in help_commands.keys():
173
if help in help_commands.keys():
465
174
# some commands are hidden
466
175
help = help_commands[cmd_name]
467
self.assertNotContainsRe(help, 'plugin "[^"]*"')
176
self.assertNotContainsRe(help, 'From plugin "[^"]*"')
469
178
def test_plugin_help_shows_plugin(self):
470
179
# Create a test plugin
471
180
os.mkdir('plugin_test')
472
f = open(osutils.pathjoin('plugin_test', 'myplug.py'), 'w')
474
from bzrlib import commands
475
class cmd_myplug(commands.Command):
476
__doc__ = '''Just a simple test plugin.'''
479
print 'Hello from my plugin'
181
f = open(pathjoin('plugin_test', 'myplug.py'), 'w')
487
bzrlib.plugin.load_from_path(['plugin_test'])
187
bzrlib.plugin.load_from_dirs(['plugin_test'])
488
188
bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
489
help = self.run_bzr('help myplug')[0]
490
self.assertContainsRe(help, 'plugin "myplug"')
189
help = self.capture('help myplug')
190
self.assertContainsRe(help, 'From plugin "myplug"')
491
191
help = self.split_help_commands()['myplug']
492
self.assertContainsRe(help, '\[myplug\]')
495
if 'myplug' in bzrlib.commands.plugin_cmds:
496
bzrlib.commands.plugin_cmds.remove('myplug')
497
# remove the plugin 'myplug'
498
if getattr(bzrlib.plugins, 'myplug', None):
499
delattr(bzrlib.plugins, 'myplug')
502
class TestHelpIndex(tests.TestCase):
503
"""Tests for the PluginsHelpIndex class."""
505
def test_default_constructable(self):
506
index = plugin.PluginsHelpIndex()
508
def test_get_topics_None(self):
509
"""Searching for None returns an empty list."""
510
index = plugin.PluginsHelpIndex()
511
self.assertEqual([], index.get_topics(None))
513
def test_get_topics_for_plugin(self):
514
"""Searching for plugin name gets its docstring."""
515
index = plugin.PluginsHelpIndex()
516
# make a new plugin here for this test, even if we're run with
518
self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
519
demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
520
sys.modules['bzrlib.plugins.demo_module'] = demo_module
522
topics = index.get_topics('demo_module')
523
self.assertEqual(1, len(topics))
524
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
525
self.assertEqual(demo_module, topics[0].module)
527
del sys.modules['bzrlib.plugins.demo_module']
529
def test_get_topics_no_topic(self):
530
"""Searching for something that is not a plugin returns []."""
531
# test this by using a name that cannot be a plugin - its not
532
# a valid python identifier.
533
index = plugin.PluginsHelpIndex()
534
self.assertEqual([], index.get_topics('nothing by this name'))
536
def test_prefix(self):
537
"""PluginsHelpIndex has a prefix of 'plugins/'."""
538
index = plugin.PluginsHelpIndex()
539
self.assertEqual('plugins/', index.prefix)
541
def test_get_plugin_topic_with_prefix(self):
542
"""Searching for plugins/demo_module returns help."""
543
index = plugin.PluginsHelpIndex()
544
self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
545
demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
546
sys.modules['bzrlib.plugins.demo_module'] = demo_module
548
topics = index.get_topics('plugins/demo_module')
549
self.assertEqual(1, len(topics))
550
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
551
self.assertEqual(demo_module, topics[0].module)
553
del sys.modules['bzrlib.plugins.demo_module']
556
class FakeModule(object):
557
"""A fake module to test with."""
559
def __init__(self, doc, name):
564
class TestModuleHelpTopic(tests.TestCase):
565
"""Tests for the ModuleHelpTopic class."""
567
def test_contruct(self):
568
"""Construction takes the module to document."""
569
mod = FakeModule('foo', 'foo')
570
topic = plugin.ModuleHelpTopic(mod)
571
self.assertEqual(mod, topic.module)
573
def test_get_help_text_None(self):
574
"""A ModuleHelpTopic returns the docstring for get_help_text."""
575
mod = FakeModule(None, 'demo')
576
topic = plugin.ModuleHelpTopic(mod)
577
self.assertEqual("Plugin 'demo' has no docstring.\n",
578
topic.get_help_text())
580
def test_get_help_text_no_carriage_return(self):
581
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
582
mod = FakeModule('one line of help', 'demo')
583
topic = plugin.ModuleHelpTopic(mod)
584
self.assertEqual("one line of help\n",
585
topic.get_help_text())
587
def test_get_help_text_carriage_return(self):
588
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
589
mod = FakeModule('two lines of help\nand more\n', 'demo')
590
topic = plugin.ModuleHelpTopic(mod)
591
self.assertEqual("two lines of help\nand more\n",
592
topic.get_help_text())
594
def test_get_help_text_with_additional_see_also(self):
595
mod = FakeModule('two lines of help\nand more', 'demo')
596
topic = plugin.ModuleHelpTopic(mod)
597
self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
598
topic.get_help_text(['foo', 'bar']))
600
def test_get_help_topic(self):
601
"""The help topic for a plugin is its module name."""
602
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
603
topic = plugin.ModuleHelpTopic(mod)
604
self.assertEqual('demo', topic.get_help_topic())
605
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
606
topic = plugin.ModuleHelpTopic(mod)
607
self.assertEqual('foo_bar', topic.get_help_topic())
610
class TestLoadFromPath(tests.TestCaseInTempDir):
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)
618
# Monkey-patch load_from_path to stop it from actually loading anything.
619
self.overrideAttr(plugin, 'load_from_path', lambda dirs: None)
621
def test_set_plugins_path_with_args(self):
622
plugin.set_plugins_path(['a', 'b'])
623
self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
625
def test_set_plugins_path_defaults(self):
626
plugin.set_plugins_path()
627
self.assertEqual(plugin.get_standard_plugins_path(),
628
bzrlib.plugins.__path__)
630
def test_get_standard_plugins_path(self):
631
path = plugin.get_standard_plugins_path()
632
for directory in path:
633
self.assertNotContainsRe(directory, r'\\/$')
635
from distutils.sysconfig import get_python_lib
639
if sys.platform != 'win32':
640
python_lib = get_python_lib()
641
for directory in path:
642
if directory.startswith(python_lib):
645
self.fail('No path to global plugins')
647
def test_get_standard_plugins_path_env(self):
648
os.environ['BZR_PLUGIN_PATH'] = 'foo/'
649
path = plugin.get_standard_plugins_path()
650
for directory in path:
651
self.assertNotContainsRe(directory, r'\\/$')
653
def test_load_plugins(self):
654
plugin.load_plugins(['.'])
655
self.assertEqual(bzrlib.plugins.__path__, ['.'])
656
# subsequent loads are no-ops
657
plugin.load_plugins(['foo'])
658
self.assertEqual(bzrlib.plugins.__path__, ['.'])
660
def test_load_plugins_default(self):
661
plugin.load_plugins()
662
path = plugin.get_standard_plugins_path()
663
self.assertEqual(path, bzrlib.plugins.__path__)
666
class TestEnvPluginPath(tests.TestCase):
669
super(TestEnvPluginPath, self).setUp()
670
self.overrideAttr(plugin, 'DEFAULT_PLUGIN_PATH', None)
672
self.user = plugin.get_user_plugin_path()
673
self.site = plugin.get_site_plugin_path()
674
self.core = plugin.get_core_plugin_path()
676
def _list2paths(self, *args):
679
plugin._append_new_path(paths, p)
682
def _set_path(self, *args):
683
path = os.pathsep.join(self._list2paths(*args))
684
osutils.set_or_unset_env('BZR_PLUGIN_PATH', path)
686
def check_path(self, expected_dirs, setting_dirs):
688
self._set_path(*setting_dirs)
689
actual = plugin.get_standard_plugins_path()
690
self.assertEquals(self._list2paths(*expected_dirs), actual)
692
def test_default(self):
693
self.check_path([self.user, self.core, self.site],
696
def test_adhoc_policy(self):
697
self.check_path([self.user, self.core, self.site],
698
['+user', '+core', '+site'])
700
def test_fallback_policy(self):
701
self.check_path([self.core, self.site, self.user],
702
['+core', '+site', '+user'])
704
def test_override_policy(self):
705
self.check_path([self.user, self.site, self.core],
706
['+user', '+site', '+core'])
708
def test_disable_user(self):
709
self.check_path([self.core, self.site], ['-user'])
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'])
715
def test_duplicates_are_removed(self):
716
self.check_path([self.user, self.core, self.site],
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',
725
def test_disable_overrides_enable(self):
726
self.check_path([self.core, self.site], ['-user', '+user'])
728
def test_disable_core(self):
729
self.check_path([self.site], ['-core'])
730
self.check_path([self.user, self.site], ['+user', '-core'])
732
def test_disable_site(self):
733
self.check_path([self.core], ['-site'])
734
self.check_path([self.user, self.core], ['-site', '+user'])
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],
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],
748
def test_my_plugin_only(self):
749
self.check_path(['myplugin'], ['myplugin', '-user', '-core', '-site'])
751
def test_my_plugin_first(self):
752
self.check_path(['myplugin', self.core, self.site, self.user],
753
['myplugin', '+core', '+site', '+user'])
755
def test_bogus_references(self):
756
self.check_path(['+foo', '-bar', self.core, self.site],
760
class TestDisablePlugin(tests.TestCaseInTempDir, TestPluginMixin):
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')
770
def test_cannot_import(self):
771
osutils.set_or_unset_env('BZR_DISABLE_PLUGINS', 'test_foo')
772
plugin.set_plugins_path(['.'])
774
import bzrlib.plugins.test_foo
777
self.assertPluginUnknown('test_foo')
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)
786
def test_not_loaded(self):
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)
801
class TestLoadPluginAt(tests.TestCaseInTempDir, TestPluginMixin):
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')
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)
823
def test_regular_load(self):
824
plugin.load_plugins(['standard'])
825
self.assertTestFooLoadedFrom('standard/test_foo')
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'])
831
import bzrlib.plugins.test_foo
834
self.assertTestFooLoadedFrom('non-standard-dir')
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')
841
def test_compiled_loaded(self):
842
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
843
plugin.load_plugins(['standard'])
844
self.assertTestFooLoadedFrom('non-standard-dir')
845
self.assertEqual('non-standard-dir/__init__.py',
846
bzrlib.plugins.test_foo.__file__)
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')
857
self.assertEqual('non-standard-dir/__init__.%s' % suffix,
858
bzrlib.plugins.test_foo.__file__)
860
def test_submodule_loading(self):
861
# We create an additional directory under the one for test_foo
862
self.create_plugin_package('test_bar', dir='non-standard-dir/test_bar')
863
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
864
plugin.set_plugins_path(['standard'])
865
import bzrlib.plugins.test_foo
866
self.assertEqual('bzrlib.plugins.test_foo',
867
bzrlib.plugins.test_foo.__package__)
868
import bzrlib.plugins.test_foo.test_bar
869
self.assertEqual('non-standard-dir/test_bar/__init__.py',
870
bzrlib.plugins.test_foo.test_bar.__file__)
872
def test_loading_from___init__only(self):
873
# We rename the existing __init__.py file to ensure that we don't load
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')
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)
888
"""This is the doc for %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)
192
self.assertContainsRe(help, 'From plugin "myplug"')
194
# remove the plugin 'plugin'
195
if getattr(bzrlib.plugins, 'plugin', None):
196
del bzrlib.plugins.plugin
added
removed
bzrlib/tests/test_plugins.py
