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
23
from cStringIO import StringIO
34
from ..sixish import (
38
41
# TODO: Write a test for plugin decoration of commands.
40
class TestPluginMixin(object):
43
invalidate_caches = getattr(importlib, "invalidate_caches", lambda: None)
46
class BaseTestPlugins(tests.TestCaseInTempDir):
47
"""TestCase that isolates plugin imports and cleans up on completion."""
50
super(BaseTestPlugins, self).setUp()
51
self.module_name = "breezy.testingplugins"
52
self.module_prefix = self.module_name + "."
53
self.module = types.ModuleType(self.module_name)
55
self.overrideAttr(plugin, "_MODULE_PREFIX", self.module_prefix)
56
self.overrideAttr(breezy, "testingplugins", self.module)
58
sys.modules[self.module_name] = self.module
59
self.addCleanup(self._unregister_all)
60
self.addCleanup(self._unregister_finder)
65
"""Remove all global testing state and clean up module."""
66
# GZ 2017-06-02: Ideally don't do this, write new test or generate
67
# bytecode by other mechanism.
68
self.log("resetting plugin testing context")
69
self._unregister_all()
70
self._unregister_finder()
71
sys.modules[self.module_name] = self.module
72
for name in list(self.module.__dict__):
74
delattr(self.module, name)
78
def update_module_paths(self, paths):
79
paths = plugin.extend_path(paths, self.module_name)
80
self.module.__path__ = paths
81
self.log("using %r", paths)
84
def load_with_paths(self, paths):
85
self.log("loading plugins!")
86
plugin.load_plugins(self.update_module_paths(paths), state=self)
42
88
def create_plugin(self, name, source=None, dir='.', file_name=None):
68
# Workaround lazy import random? madness
70
self.addCleanup(cleanup)
71
109
self.create_plugin(name, source, dir,
72
110
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)
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)),
82
146
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)
147
self.assertTrue(getattr(self.module, name, None) is None)
148
self.assertFalse(self.module_prefix + name in sys.modules)
86
150
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):
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):
93
157
activeattributes = {}
98
162
# file name we can use which is also a valid attribute for accessing in
99
163
# activeattributes. - we cannot give import parameters.
100
164
tempattribute = "0"
101
self.failIf(tempattribute in self.activeattributes)
165
self.assertFalse(tempattribute in self.activeattributes)
102
166
# set a place for the plugins to record their loading, and at the same
103
167
# time validate that the location the plugins should record to is
104
168
# valid and correct.
105
169
self.__class__.activeattributes [tempattribute] = []
106
self.failUnless(tempattribute in self.activeattributes)
170
self.assertTrue(tempattribute in self.activeattributes)
107
171
# create two plugin directories
108
172
os.mkdir('first')
109
173
os.mkdir('second')
110
174
# write a plugin that will record when its loaded in the
111
175
# tempattribute list.
112
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
176
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
113
177
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
115
outfile = open(os.path.join('first', 'plugin.py'), 'w')
179
with open(os.path.join('first', 'plugin.py'), 'w') as outfile:
117
180
outfile.write(template % (tempattribute, 'first'))
118
181
outfile.write('\n')
122
outfile = open(os.path.join('second', 'plugin.py'), 'w')
183
with open(os.path.join('second', 'plugin.py'), 'w') as outfile:
124
184
outfile.write(template % (tempattribute, 'second'))
125
185
outfile.write('\n')
130
bzrlib.plugin.load_from_path(['first', 'second'])
188
self.load_with_paths(['first', 'second'])
131
189
self.assertEqual(['first'], self.activeattributes[tempattribute])
133
# remove the plugin 'plugin'
134
191
del self.activeattributes[tempattribute]
135
self._unregister_plugin('plugin')
136
self.assertPluginUnknown('plugin')
138
193
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)
194
self.assertFalse('breezy.plugins.pluginone' in sys.modules)
195
self.assertFalse('breezy.plugins.plugintwo' in sys.modules)
141
196
# This test tests that having two plugins in different
142
197
# directories with different names allows them both to be loaded, when
143
198
# we do a direct import statement.
144
199
# Determine a file name we can use which is also a valid attribute
145
200
# for accessing in activeattributes. - we cannot give import parameters.
146
201
tempattribute = "different-dirs"
147
self.failIf(tempattribute in self.activeattributes)
202
self.assertFalse(tempattribute in self.activeattributes)
148
203
# set a place for the plugins to record their loading, and at the same
149
204
# time validate that the location the plugins should record to is
150
205
# valid and correct.
151
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
206
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \
152
207
[tempattribute] = []
153
self.failUnless(tempattribute in self.activeattributes)
208
self.assertTrue(tempattribute in self.activeattributes)
154
209
# create two plugin directories
155
210
os.mkdir('first')
156
211
os.mkdir('second')
157
212
# write plugins that will record when they are loaded in the
158
213
# tempattribute list.
159
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
214
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
160
215
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
162
outfile = open(os.path.join('first', 'pluginone.py'), 'w')
217
with open(os.path.join('first', 'pluginone.py'), 'w') as outfile:
164
218
outfile.write(template % (tempattribute, 'first'))
165
219
outfile.write('\n')
169
outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
221
with open(os.path.join('second', 'plugintwo.py'), 'w') as outfile:
171
222
outfile.write(template % (tempattribute, 'second'))
172
223
outfile.write('\n')
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"
226
self.assertPluginUnknown('pluginone')
227
self.assertPluginUnknown('plugintwo')
228
self.update_module_paths(['first', 'second'])
229
exec("import %spluginone" % self.module_prefix)
182
230
self.assertEqual(['first'], self.activeattributes[tempattribute])
183
exec "import bzrlib.plugins.plugintwo"
231
exec("import %splugintwo" % self.module_prefix)
184
232
self.assertEqual(['first', 'second'],
185
233
self.activeattributes[tempattribute])
187
# remove the plugin 'plugin'
188
235
del self.activeattributes[tempattribute]
189
self._unregister_plugin('pluginone')
190
self._unregister_plugin('plugintwo')
191
self.assertPluginUnknown('pluginone')
192
self.assertPluginUnknown('plugintwo')
194
237
def test_plugins_can_load_from_directory_with_trailing_slash(self):
195
238
# This test tests that a plugin can load from a directory when the
197
240
# check the plugin is not loaded already
198
241
self.assertPluginUnknown('ts_plugin')
199
242
tempattribute = "trailing-slash"
200
self.failIf(tempattribute in self.activeattributes)
243
self.assertFalse(tempattribute in self.activeattributes)
201
244
# set a place for the plugin to record its loading, and at the same
202
245
# time validate that the location the plugin should record to is
203
246
# valid and correct.
204
bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
247
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \
205
248
[tempattribute] = []
206
self.failUnless(tempattribute in self.activeattributes)
249
self.assertTrue(tempattribute in self.activeattributes)
207
250
# create a directory for the plugin
208
251
os.mkdir('plugin_test')
209
252
# write a plugin that will record when its loaded in the
210
253
# tempattribute list.
211
template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
254
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
212
255
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
214
outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
257
with open(os.path.join('plugin_test', 'ts_plugin.py'), 'w') as outfile:
216
258
outfile.write(template % (tempattribute, 'plugin'))
217
259
outfile.write('\n')
222
bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
262
self.load_with_paths(['plugin_test'+os.sep])
223
263
self.assertEqual(['plugin'], self.activeattributes[tempattribute])
264
self.assertPluginKnown('ts_plugin')
225
266
del self.activeattributes[tempattribute]
226
self._unregister_plugin('ts_plugin')
227
self.assertPluginUnknown('ts_plugin')
229
268
def load_and_capture(self, name):
230
269
"""Load plugins from '.' capturing the output.
258
291
def test_plugin_with_bad_api_version_reports(self):
259
# This plugin asks for bzrlib api version 1.0.0, which is not supported
292
"""Try loading a plugin that requests an unsupported api.
294
Observe that it records the problem but doesn't complain on stderr.
296
See https://bugs.launchpad.net/bzr/+bug/704195
261
298
name = 'wants100.py'
264
f.write("import bzrlib.api\n"
265
"bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
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")
269
303
log = self.load_and_capture(name)
270
self.assertContainsRe(log,
271
r"It requested API version")
304
self.assertNotContainsRe(log,
305
r"It supports breezy version")
306
self.assertEqual({'wants100'}, viewkeys(self.plugin_warnings))
307
self.assertContainsRe(
308
self.plugin_warnings['wants100'][0],
309
r"It supports breezy version")
273
311
def test_plugin_with_bad_name_does_not_load(self):
274
312
# The file name here invalid for a python module.
275
name = 'bzr-bad plugin-name..py'
276
file(name, 'w').close()
313
name = 'brz-bad plugin-name..py'
314
open(name, 'w').close()
277
315
log = self.load_and_capture(name)
278
316
self.assertContainsRe(log,
279
r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
317
r"Unable to load 'brz-bad plugin-name\.' in '\.' as a plugin "
280
318
"because the file path isn't a valid module name; try renaming "
281
"it to 'bad_plugin_name_'\.")
284
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
319
"it to 'bad_plugin_name_'\\.")
322
class TestPlugins(BaseTestPlugins):
286
324
def setup_plugin(self, source=""):
287
# This test tests a new plugin appears in bzrlib.plugin.plugins().
325
# This test tests a new plugin appears in breezy.plugin.plugins().
288
326
# check the plugin is not loaded already
289
327
self.assertPluginUnknown('plugin')
290
328
# 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')
329
with open('plugin.py', 'w') as f: f.write(source + '\n')
330
self.load_with_paths(['.'])
332
def test_plugin_loaded(self):
333
self.assertPluginUnknown('plugin')
334
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
336
p = breezy.plugin.get_loaded_plugin('plugin')
337
self.assertIsInstance(p, breezy.plugin.PlugIn)
338
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
340
def test_plugin_loaded_disabled(self):
341
self.assertPluginUnknown('plugin')
342
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
344
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
299
346
def test_plugin_appears_in_plugins(self):
300
347
self.setup_plugin()
301
348
self.assertPluginKnown('plugin')
302
p = plugin.plugins()['plugin']
303
self.assertIsInstance(p, bzrlib.plugin.PlugIn)
304
self.assertEqual(p.module, plugins.plugin)
349
p = self.plugins['plugin']
350
self.assertIsInstance(p, breezy.plugin.PlugIn)
351
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
306
353
def test_trivial_plugin_get_path(self):
307
354
self.setup_plugin()
308
p = plugin.plugins()['plugin']
355
p = self.plugins['plugin']
309
356
plugin_path = self.test_dir + '/plugin.py'
310
357
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
312
359
def test_plugin_get_path_py_not_pyc(self):
313
360
# first import creates plugin.pyc
314
361
self.setup_plugin()
315
self.teardown_plugin()
316
plugin.load_from_path(['.']) # import plugin.pyc
362
self.promote_cache(self.test_dir)
364
self.load_with_paths(['.']) # import plugin.pyc
317
365
p = plugin.plugins()['plugin']
318
366
plugin_path = self.test_dir + '/plugin.py'
319
367
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
381
427
def test_no_version_info___version__(self):
382
428
self.setup_plugin()
383
plugin = bzrlib.plugin.plugins()['plugin']
429
plugin = breezy.plugin.plugins()['plugin']
384
430
self.assertEqual("unknown", plugin.__version__)
386
432
def test_str__version__with_version_info(self):
387
433
self.setup_plugin("version_info = '1.2.3'")
388
plugin = bzrlib.plugin.plugins()['plugin']
434
plugin = breezy.plugin.plugins()['plugin']
389
435
self.assertEqual("1.2.3", plugin.__version__)
391
437
def test_noniterable__version__with_version_info(self):
392
438
self.setup_plugin("version_info = (1)")
393
plugin = bzrlib.plugin.plugins()['plugin']
439
plugin = breezy.plugin.plugins()['plugin']
394
440
self.assertEqual("1", plugin.__version__)
396
442
def test_1__version__with_version_info(self):
397
443
self.setup_plugin("version_info = (1,)")
398
plugin = bzrlib.plugin.plugins()['plugin']
444
plugin = breezy.plugin.plugins()['plugin']
399
445
self.assertEqual("1", plugin.__version__)
401
447
def test_1_2__version__with_version_info(self):
402
448
self.setup_plugin("version_info = (1, 2)")
403
plugin = bzrlib.plugin.plugins()['plugin']
449
plugin = breezy.plugin.plugins()['plugin']
404
450
self.assertEqual("1.2", plugin.__version__)
406
452
def test_1_2_3__version__with_version_info(self):
407
453
self.setup_plugin("version_info = (1, 2, 3)")
408
plugin = bzrlib.plugin.plugins()['plugin']
454
plugin = breezy.plugin.plugins()['plugin']
409
455
self.assertEqual("1.2.3", plugin.__version__)
411
457
def test_candidate__version__with_version_info(self):
412
458
self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
413
plugin = bzrlib.plugin.plugins()['plugin']
459
plugin = breezy.plugin.plugins()['plugin']
414
460
self.assertEqual("1.2.3rc1", plugin.__version__)
416
462
def test_dev__version__with_version_info(self):
417
463
self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
418
plugin = bzrlib.plugin.plugins()['plugin']
464
plugin = breezy.plugin.plugins()['plugin']
419
465
self.assertEqual("1.2.3dev", plugin.__version__)
421
467
def test_dev_fallback__version__with_version_info(self):
422
468
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
423
plugin = bzrlib.plugin.plugins()['plugin']
469
plugin = breezy.plugin.plugins()['plugin']
424
470
self.assertEqual("1.2.3dev4", plugin.__version__)
426
472
def test_final__version__with_version_info(self):
427
473
self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
428
plugin = bzrlib.plugin.plugins()['plugin']
474
plugin = breezy.plugin.plugins()['plugin']
429
475
self.assertEqual("1.2.3", plugin.__version__)
431
477
def test_final_fallback__version__with_version_info(self):
432
478
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):
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')
479
plugin = breezy.plugin.plugins()['plugin']
480
self.assertEqual("1.2.3.2", plugin.__version__)
502
483
class TestHelpIndex(tests.TestCase):
594
575
def test_get_help_text_with_additional_see_also(self):
595
576
mod = FakeModule('two lines of help\nand more', 'demo')
596
577
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']))
578
self.assertEqual("two lines of help\nand more\n\n:See also: bar, foo\n",
579
topic.get_help_text(['foo', 'bar']))
600
581
def test_get_help_topic(self):
601
582
"""The help topic for a plugin is its module name."""
602
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
583
mod = FakeModule('two lines of help\nand more', 'breezy.plugins.demo')
603
584
topic = plugin.ModuleHelpTopic(mod)
604
585
self.assertEqual('demo', topic.get_help_topic())
605
mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
586
mod = FakeModule('two lines of help\nand more',
587
'breezy.plugins.foo_bar')
606
588
topic = plugin.ModuleHelpTopic(mod)
607
589
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
592
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
598
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)
599
if setting_dirs is None:
600
del os.environ['BRZ_PLUGIN_PATH']
602
os.environ['BRZ_PLUGIN_PATH'] = os.pathsep.join(setting_dirs)
603
actual = [(p if t == 'path' else t.upper())
604
for p, t in plugin._env_plugin_path()]
605
self.assertEqual(expected_dirs, actual)
692
607
def test_default(self):
693
608
self.check_path([self.user, self.core, self.site],
757
672
['+foo', '-bar'])
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')
675
class TestDisablePlugin(BaseTestPlugins):
770
677
def test_cannot_import(self):
771
osutils.set_or_unset_env('BZR_DISABLE_PLUGINS', 'test_foo')
772
plugin.set_plugins_path(['.'])
678
self.create_plugin_package('works')
679
self.create_plugin_package('fails')
680
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'fails')
681
self.update_module_paths(["."])
682
import breezy.testingplugins.works as works
774
import bzrlib.plugins.test_foo
684
import breezy.testingplugins.fails as fails
775
685
except ImportError:
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):
688
self.fail("Loaded blocked plugin: " + repr(fails))
689
self.assertPluginModules({'fails': None, 'works': works})
691
def test_partial_imports(self):
692
self.create_plugin('good')
693
self.create_plugin('bad')
694
self.create_plugin_package('ugly')
695
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'bad:ugly')
696
self.load_with_paths(['.'])
697
self.assertEqual({'good'}, viewkeys(self.plugins))
698
self.assertPluginModules({
699
'good': self.plugins['good'].module,
703
# Ensure there are no warnings about plugins not being imported as
704
# the user has explictly requested they be disabled.
705
self.assertNotContainsRe(self.get_log(), r"Unable to load plugin")
708
class TestEnvDisablePlugins(tests.TestCase):
710
def _get_names(self, env_value):
711
os.environ['BRZ_DISABLE_PLUGINS'] = env_value
712
return plugin._env_disable_plugins()
714
def test_unset(self):
715
self.assertEqual([], plugin._env_disable_plugins())
717
def test_empty(self):
718
self.assertEqual([], self._get_names(''))
720
def test_single(self):
721
self.assertEqual(['single'], self._get_names('single'))
723
def test_multi(self):
724
expected = ['one', 'two']
725
self.assertEqual(expected, self._get_names(os.pathsep.join(expected)))
727
def test_mixed(self):
728
value = os.pathsep.join(['valid', 'in-valid'])
729
self.assertEqual(['valid'], self._get_names(value))
730
self.assertContainsRe(self.get_log(),
731
r"Invalid name 'in-valid' in BRZ_DISABLE_PLUGINS=" + repr(value))
734
class TestEnvPluginsAt(tests.TestCase):
736
def _get_paths(self, env_value):
737
os.environ['BRZ_PLUGINS_AT'] = env_value
738
return plugin._env_plugins_at()
740
def test_empty(self):
741
self.assertEqual([], plugin._env_plugins_at())
742
self.assertEqual([], self._get_paths(''))
744
def test_one_path(self):
745
self.assertEqual([('b', 'man')], self._get_paths('b@man'))
747
def test_multiple(self):
749
[('tools', 'bzr-tools'), ('p', 'play.py')],
750
self._get_paths(os.pathsep.join(('tools@bzr-tools', 'p@play.py'))))
752
def test_many_at(self):
754
[('church', 'StMichael@Plea@Norwich')],
755
self._get_paths('church@StMichael@Plea@Norwich'))
757
def test_only_py(self):
758
self.assertEqual([('test', './test.py')], self._get_paths('./test.py'))
760
def test_only_package(self):
761
self.assertEqual([('py', '/opt/b/py')], self._get_paths('/opt/b/py'))
763
def test_bad_name(self):
764
self.assertEqual([], self._get_paths('/usr/local/bzr-git'))
765
self.assertContainsRe(self.get_log(),
766
r"Invalid name 'bzr-git' in BRZ_PLUGINS_AT='/usr/local/bzr-git'")
769
class TestLoadPluginAt(BaseTestPlugins):
804
772
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
773
# Create the same plugin in two directories
812
774
self.create_plugin_package('test_foo', dir='non-standard-dir')
813
775
# The "normal" directory, we use 'standard' instead of 'plugins' to
817
779
def assertTestFooLoadedFrom(self, path):
818
780
self.assertPluginKnown('test_foo')
819
781
self.assertDocstring('This is the doc for test_foo',
820
bzrlib.plugins.test_foo)
821
self.assertEqual(path, bzrlib.plugins.test_foo.dir_source)
782
self.module.test_foo)
783
self.assertEqual(path, self.module.test_foo.dir_source)
823
785
def test_regular_load(self):
824
plugin.load_plugins(['standard'])
786
self.load_with_paths(['standard'])
825
787
self.assertTestFooLoadedFrom('standard/test_foo')
827
789
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
790
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
791
self.update_module_paths(['standard'])
792
import breezy.testingplugins.test_foo
834
793
self.assertTestFooLoadedFrom('non-standard-dir')
836
795
def test_loading(self):
837
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
838
plugin.load_plugins(['standard'])
796
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
797
self.load_with_paths(['standard'])
798
self.assertTestFooLoadedFrom('non-standard-dir')
800
def test_loading_other_name(self):
801
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
802
os.rename('standard/test_foo', 'standard/test_bar')
803
self.load_with_paths(['standard'])
839
804
self.assertTestFooLoadedFrom('non-standard-dir')
841
806
def test_compiled_loaded(self):
842
osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
843
plugin.load_plugins(['standard'])
807
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
808
self.load_with_paths(['standard'])
844
809
self.assertTestFooLoadedFrom('non-standard-dir')
845
self.assertEqual('non-standard-dir/__init__.py',
846
bzrlib.plugins.test_foo.__file__)
810
self.assertIsSameRealPath('non-standard-dir/__init__.py',
811
self.module.test_foo.__file__)
848
813
# 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'])
814
os.remove('non-standard-dir/__init__.py')
815
self.promote_cache('non-standard-dir')
817
self.load_with_paths(['standard'])
852
818
self.assertTestFooLoadedFrom('non-standard-dir')
857
self.assertEqual('non-standard-dir/__init__.%s' % suffix,
858
bzrlib.plugins.test_foo.__file__)
819
suffix = plugin.COMPILED_EXT
820
self.assertIsSameRealPath('non-standard-dir/__init__' + suffix,
821
self.module.test_foo.__file__)
860
823
def test_submodule_loading(self):
861
824
# We create an additional directory under the one for test_foo
862
825
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__)
826
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
827
self.update_module_paths(['standard'])
828
import breezy.testingplugins.test_foo
829
self.assertEqual(self.module_prefix + 'test_foo',
830
self.module.test_foo.__package__)
831
import breezy.testingplugins.test_foo.test_bar
832
self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
833
self.module.test_foo.test_bar.__file__)
835
def test_relative_submodule_loading(self):
836
self.create_plugin_package('test_foo', dir='another-dir', source='''
837
from . import test_bar
839
# We create an additional directory under the one for test_foo
840
self.create_plugin_package('test_bar', dir='another-dir/test_bar')
841
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@another-dir')
842
self.update_module_paths(['standard'])
843
import breezy.testingplugins.test_foo
844
self.assertEqual(self.module_prefix + 'test_foo',
845
self.module.test_foo.__package__)
846
self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
847
self.module.test_foo.test_bar.__file__)
872
849
def test_loading_from___init__only(self):
873
850
# We rename the existing __init__.py file to ensure that we don't load