18
17
"""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
23
from cStringIO import StringIO
32
from ..tests.features import pkg_resources_feature
33
from ..sixish import (
39
38
# TODO: Write a test for plugin decoration of commands.
41
invalidate_caches = getattr(importlib, "invalidate_caches", lambda: None)
44
class BaseTestPlugins(tests.TestCaseInTempDir):
45
"""TestCase that isolates plugin imports and cleans up on completion."""
48
super(BaseTestPlugins, self).setUp()
49
self.module_name = "breezy.testingplugins"
50
self.module_prefix = self.module_name + "."
51
self.module = types.ModuleType(self.module_name)
53
self.overrideAttr(plugin, "_MODULE_PREFIX", self.module_prefix)
54
self.overrideAttr(breezy, "testingplugins", self.module)
56
sys.modules[self.module_name] = self.module
57
self.addCleanup(self._unregister_all)
58
self.addCleanup(self._unregister_finder)
63
"""Remove all global testing state and clean up module."""
64
# GZ 2017-06-02: Ideally don't do this, write new test or generate
65
# bytecode by other mechanism.
66
self.log("resetting plugin testing context")
67
self._unregister_all()
68
self._unregister_finder()
69
sys.modules[self.module_name] = self.module
70
for name in list(self.module.__dict__):
72
delattr(self.module, name)
76
def update_module_paths(self, paths):
77
paths = plugin.extend_path(paths, self.module_name)
78
self.module.__path__ = paths
79
self.log("using %r", paths)
82
def load_with_paths(self, paths, warn_load_problems=True):
83
self.log("loading plugins!")
85
self.update_module_paths(paths), state=self,
86
warn_load_problems=warn_load_problems)
40
class TestPluginMixin(object):
88
42
def create_plugin(self, name, source=None, dir='.', file_name=None):
68
# Workaround lazy import random? madness
70
self.addCleanup(cleanup)
109
71
self.create_plugin(name, source, dir,
110
72
file_name='__init__.py')
112
def promote_cache(self, directory):
113
"""Move bytecode files out of __pycache__ in given directory."""
114
cache_dir = os.path.join(directory, '__pycache__')
115
if os.path.isdir(cache_dir):
116
for name in os.listdir(cache_dir):
117
magicless_name = '.'.join(name.split('.')[0::name.count('.')])
118
rel = osutils.relpath(self.test_dir, cache_dir)
119
self.log("moving %s in %s to %s", name, rel, magicless_name)
120
os.rename(os.path.join(cache_dir, name),
121
os.path.join(directory, magicless_name))
123
def _unregister_finder(self):
124
"""Removes any test copies of _PluginsAtFinder from sys.meta_path."""
125
idx = len(sys.meta_path)
128
finder = sys.meta_path[idx]
129
if getattr(finder, "prefix", "") == self.module_prefix:
130
self.log("removed %r from sys.meta_path", finder)
131
sys.meta_path.pop(idx)
133
def _unregister_all(self):
134
"""Remove all plugins in the test namespace from sys.modules."""
135
for name in list(sys.modules):
136
if name.startswith(self.module_prefix) or name == self.module_name:
137
self.log("removed %s from sys.modules", name)
138
del sys.modules[name]
140
def assertPluginModules(self, plugin_dict):
142
dict((k[len(self.module_prefix):], sys.modules[k])
143
for k in sys.modules if k.startswith(self.module_prefix)),
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)
146
82
def assertPluginUnknown(self, name):
147
self.assertTrue(getattr(self.module, name, None) is None)
148
self.assertFalse(self.module_prefix + name in sys.modules)
83
self.failIf(getattr(bzrlib.plugins, name, None) is not None)
84
self.failIf('bzrlib.plugins.%s' % name in sys.modules)
150
86
def assertPluginKnown(self, name):
151
self.assertTrue(getattr(self.module, name, None) is not None)
152
self.assertTrue(self.module_prefix + name in sys.modules)
155
class TestLoadingPlugins(BaseTestPlugins):
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):
157
93
activeattributes = {}
162
98
# file name we can use which is also a valid attribute for accessing in
163
99
# activeattributes. - we cannot give import parameters.
164
100
tempattribute = "0"
165
self.assertFalse(tempattribute in self.activeattributes)
101
self.failIf(tempattribute in self.activeattributes)
166
102
# set a place for the plugins to record their loading, and at the same
167
103
# time validate that the location the plugins should record to is
168
104
# valid and correct.
169
self.__class__.activeattributes[tempattribute] = []
170
self.assertTrue(tempattribute in self.activeattributes)
105
self.__class__.activeattributes [tempattribute] = []
106
self.failUnless(tempattribute in self.activeattributes)
171
107
# create two plugin directories
172
108
os.mkdir('first')
173
109
os.mkdir('second')
174
110
# write a plugin that will record when its loaded in the
175
111
# tempattribute list.
176
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
112
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
177
113
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
179
with open(os.path.join('first', 'plugin.py'), 'w') as outfile:
115
outfile = open(os.path.join('first', 'plugin.py'), 'w')
180
117
outfile.write(template % (tempattribute, 'first'))
181
118
outfile.write('\n')
183
with open(os.path.join('second', 'plugin.py'), 'w') as outfile:
122
outfile = open(os.path.join('second', 'plugin.py'), 'w')
184
124
outfile.write(template % (tempattribute, 'second'))
185
125
outfile.write('\n')
188
self.load_with_paths(['first', 'second'])
130
bzrlib.plugin.load_from_path(['first', 'second'])
189
131
self.assertEqual(['first'], self.activeattributes[tempattribute])
133
# remove the plugin 'plugin'
191
134
del self.activeattributes[tempattribute]
135
self._unregister_plugin('plugin')
136
self.assertPluginUnknown('plugin')
193
138
def test_plugins_from_different_dirs_can_demand_load(self):
194
self.assertFalse('breezy.plugins.pluginone' in sys.modules)
195
self.assertFalse('breezy.plugins.plugintwo' in sys.modules)
139
self.failIf('bzrlib.plugins.pluginone' in sys.modules)
140
self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
196
141
# This test tests that having two plugins in different
197
142
# directories with different names allows them both to be loaded, when
198
143
# we do a direct import statement.
199
144
# Determine a file name we can use which is also a valid attribute
200
145
# for accessing in activeattributes. - we cannot give import parameters.
201
146
tempattribute = "different-dirs"
202
self.assertFalse(tempattribute in self.activeattributes)
147
self.failIf(tempattribute in self.activeattributes)
203
148
# set a place for the plugins to record their loading, and at the same
204
149
# time validate that the location the plugins should record to is
205
150
# valid and correct.
206
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes[tempattribute] = [
208
self.assertTrue(tempattribute in self.activeattributes)
151
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
153
self.failUnless(tempattribute in self.activeattributes)
209
154
# create two plugin directories
210
155
os.mkdir('first')
211
156
os.mkdir('second')
212
157
# write plugins that will record when they are loaded in the
213
158
# tempattribute list.
214
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
159
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
215
160
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
217
with open(os.path.join('first', 'pluginone.py'), 'w') as outfile:
162
outfile = open(os.path.join('first', 'pluginone.py'), 'w')
218
164
outfile.write(template % (tempattribute, 'first'))
219
165
outfile.write('\n')
221
with open(os.path.join('second', 'plugintwo.py'), 'w') as outfile:
169
outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
222
171
outfile.write(template % (tempattribute, 'second'))
223
172
outfile.write('\n')
176
oldpath = bzrlib.plugins.__path__
226
self.assertPluginUnknown('pluginone')
227
self.assertPluginUnknown('plugintwo')
228
self.update_module_paths(['first', 'second'])
229
exec("import %spluginone" % self.module_prefix)
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"
230
182
self.assertEqual(['first'], self.activeattributes[tempattribute])
231
exec("import %splugintwo" % self.module_prefix)
183
exec "import bzrlib.plugins.plugintwo"
232
184
self.assertEqual(['first', 'second'],
233
self.activeattributes[tempattribute])
185
self.activeattributes[tempattribute])
187
# remove the plugin 'plugin'
235
188
del self.activeattributes[tempattribute]
189
self._unregister_plugin('pluginone')
190
self._unregister_plugin('plugintwo')
191
self.assertPluginUnknown('pluginone')
192
self.assertPluginUnknown('plugintwo')
237
194
def test_plugins_can_load_from_directory_with_trailing_slash(self):
238
195
# This test tests that a plugin can load from a directory when the
240
197
# check the plugin is not loaded already
241
198
self.assertPluginUnknown('ts_plugin')
242
199
tempattribute = "trailing-slash"
243
self.assertFalse(tempattribute in self.activeattributes)
200
self.failIf(tempattribute in self.activeattributes)
244
201
# set a place for the plugin to record its loading, and at the same
245
202
# time validate that the location the plugin should record to is
246
203
# valid and correct.
247
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes[tempattribute] = [
249
self.assertTrue(tempattribute in self.activeattributes)
204
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
206
self.failUnless(tempattribute in self.activeattributes)
250
207
# create a directory for the plugin
251
208
os.mkdir('plugin_test')
252
209
# write a plugin that will record when its loaded in the
253
210
# tempattribute list.
254
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
211
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
255
212
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
257
with open(os.path.join('plugin_test', 'ts_plugin.py'), 'w') as outfile:
214
outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
258
216
outfile.write(template % (tempattribute, 'plugin'))
259
217
outfile.write('\n')
262
self.load_with_paths(['plugin_test' + os.sep])
222
bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
263
223
self.assertEqual(['plugin'], self.activeattributes[tempattribute])
264
self.assertPluginKnown('ts_plugin')
266
225
del self.activeattributes[tempattribute]
226
self._unregister_plugin('ts_plugin')
227
self.assertPluginUnknown('ts_plugin')
268
def load_and_capture(self, name, warn_load_problems=True):
229
def load_and_capture(self, name):
269
230
"""Load plugins from '.' capturing the output.
271
232
:param name: The name of the plugin.
292
258
def test_plugin_with_bad_api_version_reports(self):
293
"""Try loading a plugin that requests an unsupported api.
295
Observe that it records the problem but doesn't complain on stderr
296
when warn_load_problems=False
259
# This plugin asks for bzrlib api version 1.0.0, which is not supported
298
261
name = 'wants100.py'
299
with open(name, 'w') as f:
300
f.write("import breezy\n"
301
"from breezy.errors import IncompatibleVersion\n"
302
"raise IncompatibleVersion(breezy, [(1, 0, 0)], (0, 0, 5))\n")
303
log = self.load_and_capture(name, warn_load_problems=False)
304
self.assertNotContainsRe(log, r"It supports breezy version")
305
self.assertEqual({'wants100'}, viewkeys(self.plugin_warnings))
306
self.assertContainsRe(
307
self.plugin_warnings['wants100'][0],
308
r"It supports breezy version")
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")
310
273
def test_plugin_with_bad_name_does_not_load(self):
311
274
# The file name here invalid for a python module.
312
name = 'brz-bad plugin-name..py'
313
open(name, 'w').close()
275
name = 'bzr-bad plugin-name..py'
276
file(name, 'w').close()
314
277
log = self.load_and_capture(name)
315
278
self.assertContainsRe(log,
316
r"Unable to load 'brz-bad plugin-name\.' in '\.' as a plugin "
317
"because the file path isn't a valid module name; try renaming "
318
"it to 'bad_plugin_name_'\\.")
320
def test_plugin_with_error_suppress(self):
321
# The file name here invalid for a python module.
322
name = 'some_error.py'
323
with open(name, 'w') as f:
324
f.write('raise Exception("bad")\n')
325
log = self.load_and_capture(name, warn_load_problems=False)
326
self.assertEqual('', log)
328
def test_plugin_with_error(self):
329
# The file name here invalid for a python module.
330
name = 'some_error.py'
331
with open(name, 'w') as f:
332
f.write('raise Exception("bad")\n')
333
log = self.load_and_capture(name, warn_load_problems=True)
335
'Unable to load plugin \'some_error\' from \'.\': bad\n', log)
338
class TestPlugins(BaseTestPlugins):
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):
340
286
def setup_plugin(self, source=""):
341
# This test tests a new plugin appears in breezy.plugin.plugins().
287
# This test tests a new plugin appears in bzrlib.plugin.plugins().
342
288
# check the plugin is not loaded already
343
289
self.assertPluginUnknown('plugin')
344
290
# write a plugin that _cannot_ fail to load.
345
with open('plugin.py', 'w') as f:
346
f.write(source + '\n')
347
self.load_with_paths(['.'])
349
def test_plugin_loaded(self):
350
self.assertPluginUnknown('plugin')
351
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
353
p = breezy.plugin.get_loaded_plugin('plugin')
354
self.assertIsInstance(p, breezy.plugin.PlugIn)
355
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
357
def test_plugin_loaded_disabled(self):
358
self.assertPluginUnknown('plugin')
359
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
361
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
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')
363
299
def test_plugin_appears_in_plugins(self):
364
300
self.setup_plugin()
365
301
self.assertPluginKnown('plugin')
366
p = self.plugins['plugin']
367
self.assertIsInstance(p, breezy.plugin.PlugIn)
368
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
302
p = plugin.plugins()['plugin']
303
self.assertIsInstance(p, bzrlib.plugin.PlugIn)
304
self.assertEqual(p.module, plugins.plugin)
370
306
def test_trivial_plugin_get_path(self):
371
307
self.setup_plugin()
372
p = self.plugins['plugin']
308
p = plugin.plugins()['plugin']
373
309
plugin_path = self.test_dir + '/plugin.py'
374
310
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
376
312
def test_plugin_get_path_py_not_pyc(self):
377
313
# first import creates plugin.pyc
378
314
self.setup_plugin()
379
self.promote_cache(self.test_dir)
381
self.load_with_paths(['.']) # import plugin.pyc
315
self.teardown_plugin()
316
plugin.load_from_path(['.']) # import plugin.pyc
382
317
p = plugin.plugins()['plugin']
383
318
plugin_path = self.test_dir + '/plugin.py'
384
319
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
444
381
def test_no_version_info___version__(self):
445
382
self.setup_plugin()
446
plugin = breezy.plugin.plugins()['plugin']
383
plugin = bzrlib.plugin.plugins()['plugin']
447
384
self.assertEqual("unknown", plugin.__version__)
449
386
def test_str__version__with_version_info(self):
450
387
self.setup_plugin("version_info = '1.2.3'")
451
plugin = breezy.plugin.plugins()['plugin']
388
plugin = bzrlib.plugin.plugins()['plugin']
452
389
self.assertEqual("1.2.3", plugin.__version__)
454
391
def test_noniterable__version__with_version_info(self):
455
392
self.setup_plugin("version_info = (1)")
456
plugin = breezy.plugin.plugins()['plugin']
393
plugin = bzrlib.plugin.plugins()['plugin']
457
394
self.assertEqual("1", plugin.__version__)
459
396
def test_1__version__with_version_info(self):
460
397
self.setup_plugin("version_info = (1,)")
461
plugin = breezy.plugin.plugins()['plugin']
398
plugin = bzrlib.plugin.plugins()['plugin']
462
399
self.assertEqual("1", plugin.__version__)
464
401
def test_1_2__version__with_version_info(self):
465
402
self.setup_plugin("version_info = (1, 2)")
466
plugin = breezy.plugin.plugins()['plugin']
403
plugin = bzrlib.plugin.plugins()['plugin']
467
404
self.assertEqual("1.2", plugin.__version__)
469
406
def test_1_2_3__version__with_version_info(self):
470
407
self.setup_plugin("version_info = (1, 2, 3)")
471
plugin = breezy.plugin.plugins()['plugin']
408
plugin = bzrlib.plugin.plugins()['plugin']
472
409
self.assertEqual("1.2.3", plugin.__version__)
474
411
def test_candidate__version__with_version_info(self):
475
412
self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
476
plugin = breezy.plugin.plugins()['plugin']
413
plugin = bzrlib.plugin.plugins()['plugin']
477
414
self.assertEqual("1.2.3rc1", plugin.__version__)
479
416
def test_dev__version__with_version_info(self):
480
417
self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
481
plugin = breezy.plugin.plugins()['plugin']
418
plugin = bzrlib.plugin.plugins()['plugin']
482
419
self.assertEqual("1.2.3dev", plugin.__version__)
484
421
def test_dev_fallback__version__with_version_info(self):
485
422
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
486
plugin = breezy.plugin.plugins()['plugin']
423
plugin = bzrlib.plugin.plugins()['plugin']
487
424
self.assertEqual("1.2.3dev4", plugin.__version__)
489
426
def test_final__version__with_version_info(self):
490
427
self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
491
plugin = breezy.plugin.plugins()['plugin']
428
plugin = bzrlib.plugin.plugins()['plugin']
492
429
self.assertEqual("1.2.3", plugin.__version__)
494
431
def test_final_fallback__version__with_version_info(self):
495
432
self.setup_plugin("version_info = (1, 2, 3, 'final', 2)")
496
plugin = breezy.plugin.plugins()['plugin']
497
self.assertEqual("1.2.3.2", plugin.__version__)
433
plugin = bzrlib.plugin.plugins()['plugin']
434
self.assertEqual("1.2.3.final.2", plugin.__version__)
437
class TestPluginHelp(tests.TestCaseInTempDir):
439
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]
446
help[current] = help.get(current, '') + line
450
def test_plugin_help_builtins_unaffected(self):
451
# Check we don't get false positives
452
help_commands = self.split_help_commands()
453
for cmd_name in bzrlib.commands.builtin_command_names():
454
if cmd_name in bzrlib.commands.plugin_command_names():
457
help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
458
except NotImplementedError:
459
# some commands have no help
462
self.assertNotContainsRe(help, 'plugin "[^"]*"')
464
if cmd_name in help_commands.keys():
465
# some commands are hidden
466
help = help_commands[cmd_name]
467
self.assertNotContainsRe(help, 'plugin "[^"]*"')
469
def test_plugin_help_shows_plugin(self):
470
# Create a test plugin
471
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'
487
bzrlib.plugin.load_from_path(['plugin_test'])
488
bzrlib.commands.register_command( bzrlib.plugins.myplug.cmd_myplug)
489
help = self.run_bzr('help myplug')[0]
490
self.assertContainsRe(help, 'plugin "myplug"')
491
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')
500
502
class TestHelpIndex(tests.TestCase):
573
575
mod = FakeModule(None, 'demo')
574
576
topic = plugin.ModuleHelpTopic(mod)
575
577
self.assertEqual("Plugin 'demo' has no docstring.\n",
576
topic.get_help_text())
578
topic.get_help_text())
578
580
def test_get_help_text_no_carriage_return(self):
579
581
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
580
582
mod = FakeModule('one line of help', 'demo')
581
583
topic = plugin.ModuleHelpTopic(mod)
582
584
self.assertEqual("one line of help\n",
583
topic.get_help_text())
585
topic.get_help_text())
585
587
def test_get_help_text_carriage_return(self):
586
588
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
587
589
mod = FakeModule('two lines of help\nand more\n', 'demo')
588
590
topic = plugin.ModuleHelpTopic(mod)
589
591
self.assertEqual("two lines of help\nand more\n",
590
topic.get_help_text())
592
topic.get_help_text())
592
594
def test_get_help_text_with_additional_see_also(self):
593
595
mod = FakeModule('two lines of help\nand more', 'demo')
594
596
topic = plugin.ModuleHelpTopic(mod)
596
"two lines of help\nand more\n\n:See also: bar, foo\n",
597
self.assertEqual("two lines of help\nand more\nSee also: bar, foo\n",
597
598
topic.get_help_text(['foo', 'bar']))
599
600
def test_get_help_topic(self):
600
601
"""The help topic for a plugin is its module name."""
601
mod = FakeModule('two lines of help\nand more', 'breezy.plugins.demo')
602
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
602
603
topic = plugin.ModuleHelpTopic(mod)
603
604
self.assertEqual('demo', topic.get_help_topic())
604
mod = FakeModule('two lines of help\nand more',
605
'breezy.plugins.foo_bar')
605
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
606
606
topic = plugin.ModuleHelpTopic(mod)
607
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__)
610
666
class TestEnvPluginPath(tests.TestCase):
615
entrypoints = "ENTRYPOINTS"
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)
617
686
def check_path(self, expected_dirs, setting_dirs):
618
if setting_dirs is None:
619
del os.environ['BRZ_PLUGIN_PATH']
621
os.environ['BRZ_PLUGIN_PATH'] = os.pathsep.join(setting_dirs)
622
actual = [(p if t == 'path' else t.upper())
623
for p, t in plugin._env_plugin_path()]
624
self.assertEqual(expected_dirs, actual)
688
self._set_path(*setting_dirs)
689
actual = plugin.get_standard_plugins_path()
690
self.assertEquals(self._list2paths(*expected_dirs), actual)
626
692
def test_default(self):
627
self.check_path([self.user, self.core, self.site], None)
693
self.check_path([self.user, self.core, self.site],
629
696
def test_adhoc_policy(self):
630
697
self.check_path([self.user, self.core, self.site],
696
757
['+foo', '-bar'])
699
class TestDisablePlugin(BaseTestPlugins):
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')
701
770
def test_cannot_import(self):
702
self.create_plugin_package('works')
703
self.create_plugin_package('fails')
704
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'fails')
705
self.update_module_paths(["."])
706
import breezy.testingplugins.works as works
771
osutils.set_or_unset_env('BZR_DISABLE_PLUGINS', 'test_foo')
772
plugin.set_plugins_path(['.'])
708
import breezy.testingplugins.fails as fails
774
import bzrlib.plugins.test_foo
709
775
except ImportError:
712
self.fail("Loaded blocked plugin: " + repr(fails))
713
self.assertPluginModules({'fails': None, 'works': works})
715
def test_partial_imports(self):
716
self.create_plugin('good')
717
self.create_plugin('bad')
718
self.create_plugin_package('ugly')
719
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'bad:ugly')
720
self.load_with_paths(['.'])
721
self.assertEqual({'good'}, viewkeys(self.plugins))
722
self.assertPluginModules({
723
'good': self.plugins['good'].module,
727
# Ensure there are no warnings about plugins not being imported as
728
# the user has explictly requested they be disabled.
729
self.assertNotContainsRe(self.get_log(), r"Unable to load plugin")
732
class TestEnvDisablePlugins(tests.TestCase):
734
def _get_names(self, env_value):
735
os.environ['BRZ_DISABLE_PLUGINS'] = env_value
736
return plugin._env_disable_plugins()
738
def test_unset(self):
739
self.assertEqual([], plugin._env_disable_plugins())
741
def test_empty(self):
742
self.assertEqual([], self._get_names(''))
744
def test_single(self):
745
self.assertEqual(['single'], self._get_names('single'))
747
def test_multi(self):
748
expected = ['one', 'two']
749
self.assertEqual(expected, self._get_names(os.pathsep.join(expected)))
751
def test_mixed(self):
752
value = os.pathsep.join(['valid', 'in-valid'])
753
self.assertEqual(['valid'], self._get_names(value))
754
self.assertContainsRe(
756
r"Invalid name 'in-valid' in BRZ_DISABLE_PLUGINS=" + repr(value))
759
class TestEnvPluginsAt(tests.TestCase):
761
def _get_paths(self, env_value):
762
os.environ['BRZ_PLUGINS_AT'] = env_value
763
return plugin._env_plugins_at()
765
def test_empty(self):
766
self.assertEqual([], plugin._env_plugins_at())
767
self.assertEqual([], self._get_paths(''))
769
def test_one_path(self):
770
self.assertEqual([('b', 'man')], self._get_paths('b@man'))
772
def test_multiple(self):
774
[('tools', 'bzr-tools'), ('p', 'play.py')],
775
self._get_paths(os.pathsep.join(('tools@bzr-tools', 'p@play.py'))))
777
def test_many_at(self):
779
[('church', 'StMichael@Plea@Norwich')],
780
self._get_paths('church@StMichael@Plea@Norwich'))
782
def test_only_py(self):
783
self.assertEqual([('test', './test.py')], self._get_paths('./test.py'))
785
def test_only_package(self):
786
self.assertEqual([('py', '/opt/b/py')], self._get_paths('/opt/b/py'))
788
def test_bad_name(self):
789
self.assertEqual([], self._get_paths('/usr/local/bzr-git'))
790
self.assertContainsRe(
792
r"Invalid name 'bzr-git' in BRZ_PLUGINS_AT='/usr/local/bzr-git'")
795
class TestLoadPluginAt(BaseTestPlugins):
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):
798
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)
799
811
# Create the same plugin in two directories
800
812
self.create_plugin_package('test_foo', dir='non-standard-dir')
801
813
# The "normal" directory, we use 'standard' instead of 'plugins' to
805
817
def assertTestFooLoadedFrom(self, path):
806
818
self.assertPluginKnown('test_foo')
807
819
self.assertDocstring('This is the doc for test_foo',
808
self.module.test_foo)
809
self.assertEqual(path, self.module.test_foo.dir_source)
820
bzrlib.plugins.test_foo)
821
self.assertEqual(path, bzrlib.plugins.test_foo.dir_source)
811
823
def test_regular_load(self):
812
self.load_with_paths(['standard'])
824
plugin.load_plugins(['standard'])
813
825
self.assertTestFooLoadedFrom('standard/test_foo')
815
827
def test_import(self):
816
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
817
self.update_module_paths(['standard'])
818
import breezy.testingplugins.test_foo
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
819
834
self.assertTestFooLoadedFrom('non-standard-dir')
821
836
def test_loading(self):
822
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
823
self.load_with_paths(['standard'])
824
self.assertTestFooLoadedFrom('non-standard-dir')
826
def test_loading_other_name(self):
827
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
828
os.rename('standard/test_foo', 'standard/test_bar')
829
self.load_with_paths(['standard'])
837
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
838
plugin.load_plugins(['standard'])
830
839
self.assertTestFooLoadedFrom('non-standard-dir')
832
841
def test_compiled_loaded(self):
833
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
834
self.load_with_paths(['standard'])
842
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
843
plugin.load_plugins(['standard'])
835
844
self.assertTestFooLoadedFrom('non-standard-dir')
836
self.assertIsSameRealPath('non-standard-dir/__init__.py',
837
self.module.test_foo.__file__)
845
self.assertEqual('non-standard-dir/__init__.py',
846
bzrlib.plugins.test_foo.__file__)
839
848
# Try importing again now that the source has been compiled
840
os.remove('non-standard-dir/__init__.py')
841
self.promote_cache('non-standard-dir')
843
self.load_with_paths(['standard'])
849
self._unregister_plugin('test_foo')
850
plugin._loaded = False
851
plugin.load_plugins(['standard'])
844
852
self.assertTestFooLoadedFrom('non-standard-dir')
845
suffix = plugin.COMPILED_EXT
846
self.assertIsSameRealPath('non-standard-dir/__init__' + suffix,
847
self.module.test_foo.__file__)
857
self.assertEqual('non-standard-dir/__init__.%s' % suffix,
858
bzrlib.plugins.test_foo.__file__)
849
860
def test_submodule_loading(self):
850
861
# We create an additional directory under the one for test_foo
851
862
self.create_plugin_package('test_bar', dir='non-standard-dir/test_bar')
852
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
853
self.update_module_paths(['standard'])
854
import breezy.testingplugins.test_foo # noqa: F401
855
self.assertEqual(self.module_prefix + 'test_foo',
856
self.module.test_foo.__package__)
857
import breezy.testingplugins.test_foo.test_bar # noqa: F401
858
self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
859
self.module.test_foo.test_bar.__file__)
861
def test_relative_submodule_loading(self):
862
self.create_plugin_package('test_foo', dir='another-dir', source='''
863
from . import test_bar
865
# We create an additional directory under the one for test_foo
866
self.create_plugin_package('test_bar', dir='another-dir/test_bar')
867
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@another-dir')
868
self.update_module_paths(['standard'])
869
import breezy.testingplugins.test_foo # noqa: F401
870
self.assertEqual(self.module_prefix + 'test_foo',
871
self.module.test_foo.__package__)
872
self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
873
self.module.test_foo.test_bar.__file__)
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__)
875
872
def test_loading_from___init__only(self):
876
873
# We rename the existing __init__.py file to ensure that we don't load
892
890
''' % ('test_foo', plugin_path)
893
891
self.create_plugin('test_foo', source=source,
894
892
dir=plugin_dir, file_name=plugin_file_name)
895
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@%s' % plugin_path)
896
self.load_with_paths(['standard'])
893
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@%s' % plugin_path)
894
plugin.load_plugins(['standard'])
897
895
self.assertTestFooLoadedFrom(plugin_path)
900
class TestDescribePlugins(BaseTestPlugins):
902
def test_describe_plugins(self):
903
class DummyModule(object):
906
class DummyPlugin(object):
907
__version__ = '0.1.0'
908
module = DummyModule()
909
self.plugin_warnings = {'bad': ['Failed to load (just testing)']}
910
self.plugins = {'good': DummyPlugin()}
911
self.assertEqual("""\
913
** Failed to load (just testing)
918
""", ''.join(plugin.describe_plugins(state=self)))
921
class DummyPlugin(object):
925
class TestLoadEnvPlugin(BaseTestPlugins):
927
_test_needs_features = [pkg_resources_feature]
929
def setup_plugin(self, source=""):
930
# This test tests a new plugin appears in breezy.plugin.plugins().
931
# check the plugin is not loaded already
932
self.assertPluginUnknown('plugin')
933
# write a plugin that _cannot_ fail to load.
935
d = pkg_resources.Distribution(__file__)
936
ep = pkg_resources.EntryPoint.parse(
937
'plugin = ' + __name__ + ':DummyPlugin', dist=d)
938
d._ep_map = {'breezy.plugin': {'plugin': ep}}
939
pkg_resources.working_set.add(d, 'plugin', replace=True)
940
eps = list(pkg_resources.iter_entry_points('breezy.plugin'))
941
self.assertEqual(['plugin'], [ep.name for ep in eps])
942
self.load_with_paths(['.'])
943
self.addCleanup(d._ep_map.clear)
945
def test_plugin_loaded(self):
946
self.assertPluginUnknown('plugin')
947
self.overrideEnv('BRZ_PLUGIN_PATH', '+entrypoints')
949
p = self.plugins['plugin']
950
self.assertIsInstance(p, breezy.plugin.PlugIn)
951
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
953
def test_plugin_loaded_disabled(self):
954
self.assertPluginUnknown('plugin')
955
self.overrideEnv('BRZ_PLUGIN_PATH', '+entrypoints')
956
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
958
self.assertNotIn('plugin', self.plugins)
added
removed
bzrlib/tests/test_plugins.py
