1
# Copyright (C) 2005-2012, 2016 Canonical Ltd
2
# Copyright (C) 2017-2018 Breezy developers
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
"""Tests for plugins"""
21
from io import StringIO
33
from ..tests.features import pkg_resources_feature
36
# TODO: Write a test for plugin decoration of commands.
38
invalidate_caches = getattr(importlib, "invalidate_caches", lambda: None)
41
class BaseTestPlugins(tests.TestCaseInTempDir):
42
"""TestCase that isolates plugin imports and cleans up on completion."""
45
super(BaseTestPlugins, self).setUp()
46
self.module_name = "breezy.testingplugins"
47
self.module_prefix = self.module_name + "."
48
self.module = types.ModuleType(self.module_name)
50
self.overrideAttr(plugin, "_MODULE_PREFIX", self.module_prefix)
51
self.overrideAttr(breezy, "testingplugins", self.module)
53
sys.modules[self.module_name] = self.module
54
self.addCleanup(self._unregister_all)
55
self.addCleanup(self._unregister_finder)
60
"""Remove all global testing state and clean up module."""
61
# GZ 2017-06-02: Ideally don't do this, write new test or generate
62
# bytecode by other mechanism.
63
self.log("resetting plugin testing context")
64
self._unregister_all()
65
self._unregister_finder()
66
sys.modules[self.module_name] = self.module
67
for name in list(self.module.__dict__):
69
delattr(self.module, name)
73
def update_module_paths(self, paths):
74
paths = plugin.extend_path(paths, self.module_name)
75
self.module.__path__ = paths
76
self.log("using %r", paths)
79
def load_with_paths(self, paths):
80
self.log("loading plugins!")
81
plugin.load_plugins(self.update_module_paths(paths), state=self)
83
def create_plugin(self, name, source=None, dir='.', file_name=None):
86
"""This is the doc for %s"""
89
file_name = name + '.py'
90
# 'source' must not fail to load
91
path = osutils.pathjoin(dir, file_name)
92
with open(path, 'w') as f:
93
f.write(source + '\n')
95
def create_plugin_package(self, name, dir=None, source=None):
100
"""This is the doc for %s"""
104
self.create_plugin(name, source, dir,
105
file_name='__init__.py')
107
def promote_cache(self, directory):
108
"""Move bytecode files out of __pycache__ in given directory."""
109
cache_dir = os.path.join(directory, '__pycache__')
110
if os.path.isdir(cache_dir):
111
for name in os.listdir(cache_dir):
112
magicless_name = '.'.join(name.split('.')[0::name.count('.')])
113
rel = osutils.relpath(self.test_dir, cache_dir)
114
self.log("moving %s in %s to %s", name, rel, magicless_name)
115
os.rename(os.path.join(cache_dir, name),
116
os.path.join(directory, magicless_name))
118
def _unregister_finder(self):
119
"""Removes any test copies of _PluginsAtFinder from sys.meta_path."""
120
idx = len(sys.meta_path)
123
finder = sys.meta_path[idx]
124
if getattr(finder, "prefix", "") == self.module_prefix:
125
self.log("removed %r from sys.meta_path", finder)
126
sys.meta_path.pop(idx)
128
def _unregister_all(self):
129
"""Remove all plugins in the test namespace from sys.modules."""
130
for name in list(sys.modules):
131
if name.startswith(self.module_prefix) or name == self.module_name:
132
self.log("removed %s from sys.modules", name)
133
del sys.modules[name]
135
def assertPluginModules(self, plugin_dict):
137
dict((k[len(self.module_prefix):], sys.modules[k])
138
for k in sys.modules if k.startswith(self.module_prefix)),
141
def assertPluginUnknown(self, name):
142
self.assertTrue(getattr(self.module, name, None) is None)
143
self.assertFalse(self.module_prefix + name in sys.modules)
145
def assertPluginKnown(self, name):
146
self.assertTrue(getattr(self.module, name, None) is not None)
147
self.assertTrue(self.module_prefix + name in sys.modules)
150
class TestLoadingPlugins(BaseTestPlugins):
152
activeattributes = {}
154
def test_plugins_with_the_same_name_are_not_loaded(self):
155
# This test tests that having two plugins in different directories does
156
# not result in both being loaded when they have the same name. get a
157
# file name we can use which is also a valid attribute for accessing in
158
# activeattributes. - we cannot give import parameters.
160
self.assertFalse(tempattribute in self.activeattributes)
161
# set a place for the plugins to record their loading, and at the same
162
# time validate that the location the plugins should record to is
164
self.__class__.activeattributes[tempattribute] = []
165
self.assertTrue(tempattribute in self.activeattributes)
166
# create two plugin directories
169
# write a plugin that will record when its loaded in the
170
# tempattribute list.
171
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
172
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
174
with open(os.path.join('first', 'plugin.py'), 'w') as outfile:
175
outfile.write(template % (tempattribute, 'first'))
178
with open(os.path.join('second', 'plugin.py'), 'w') as outfile:
179
outfile.write(template % (tempattribute, 'second'))
183
self.load_with_paths(['first', 'second'])
184
self.assertEqual(['first'], self.activeattributes[tempattribute])
186
del self.activeattributes[tempattribute]
188
def test_plugins_from_different_dirs_can_demand_load(self):
189
self.assertFalse('breezy.plugins.pluginone' in sys.modules)
190
self.assertFalse('breezy.plugins.plugintwo' in sys.modules)
191
# This test tests that having two plugins in different
192
# directories with different names allows them both to be loaded, when
193
# we do a direct import statement.
194
# Determine a file name we can use which is also a valid attribute
195
# for accessing in activeattributes. - we cannot give import parameters.
196
tempattribute = "different-dirs"
197
self.assertFalse(tempattribute in self.activeattributes)
198
# set a place for the plugins to record their loading, and at the same
199
# time validate that the location the plugins should record to is
201
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes[tempattribute] = [
203
self.assertTrue(tempattribute in self.activeattributes)
204
# create two plugin directories
207
# write plugins that will record when they are loaded in the
208
# tempattribute list.
209
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
210
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
212
with open(os.path.join('first', 'pluginone.py'), 'w') as outfile:
213
outfile.write(template % (tempattribute, 'first'))
216
with open(os.path.join('second', 'plugintwo.py'), 'w') as outfile:
217
outfile.write(template % (tempattribute, 'second'))
221
self.assertPluginUnknown('pluginone')
222
self.assertPluginUnknown('plugintwo')
223
self.update_module_paths(['first', 'second'])
224
exec("import %spluginone" % self.module_prefix)
225
self.assertEqual(['first'], self.activeattributes[tempattribute])
226
exec("import %splugintwo" % self.module_prefix)
227
self.assertEqual(['first', 'second'],
228
self.activeattributes[tempattribute])
230
del self.activeattributes[tempattribute]
232
def test_plugins_can_load_from_directory_with_trailing_slash(self):
233
# This test tests that a plugin can load from a directory when the
234
# directory in the path has a trailing slash.
235
# check the plugin is not loaded already
236
self.assertPluginUnknown('ts_plugin')
237
tempattribute = "trailing-slash"
238
self.assertFalse(tempattribute in self.activeattributes)
239
# set a place for the plugin to record its loading, and at the same
240
# time validate that the location the plugin should record to is
242
breezy.tests.test_plugins.TestLoadingPlugins.activeattributes[tempattribute] = [
244
self.assertTrue(tempattribute in self.activeattributes)
245
# create a directory for the plugin
246
os.mkdir('plugin_test')
247
# write a plugin that will record when its loaded in the
248
# tempattribute list.
249
template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
250
"TestLoadingPlugins.activeattributes[%r].append('%s')\n")
252
with open(os.path.join('plugin_test', 'ts_plugin.py'), 'w') as outfile:
253
outfile.write(template % (tempattribute, 'plugin'))
257
self.load_with_paths(['plugin_test' + os.sep])
258
self.assertEqual(['plugin'], self.activeattributes[tempattribute])
259
self.assertPluginKnown('ts_plugin')
261
del self.activeattributes[tempattribute]
263
def load_and_capture(self, name):
264
"""Load plugins from '.' capturing the output.
266
:param name: The name of the plugin.
267
:return: A string with the log from the plugin loading call.
272
handler = logging.StreamHandler(stream)
273
log = logging.getLogger('brz')
274
log.addHandler(handler)
276
self.load_with_paths(['.'])
278
# Stop capturing output
281
log.removeHandler(handler)
282
return stream.getvalue()
286
def test_plugin_with_bad_api_version_reports(self):
287
"""Try loading a plugin that requests an unsupported api.
289
Observe that it records the problem but doesn't complain on stderr.
291
See https://bugs.launchpad.net/bzr/+bug/704195
294
with open(name, 'w') as f:
295
f.write("import breezy\n"
296
"from breezy.errors import IncompatibleVersion\n"
297
"raise IncompatibleVersion(breezy, [(1, 0, 0)], (0, 0, 5))\n")
298
log = self.load_and_capture(name)
299
self.assertNotContainsRe(log,
300
r"It supports breezy version")
301
self.assertEqual({'wants100'}, self.plugin_warnings.keys())
302
self.assertContainsRe(
303
self.plugin_warnings['wants100'][0],
304
r"It supports breezy version")
306
def test_plugin_with_bad_name_does_not_load(self):
307
# The file name here invalid for a python module.
308
name = 'brz-bad plugin-name..py'
309
open(name, 'w').close()
310
log = self.load_and_capture(name)
311
self.assertContainsRe(log,
312
r"Unable to load 'brz-bad plugin-name\.' in '\.' as a plugin "
313
"because the file path isn't a valid module name; try renaming "
314
"it to 'bad_plugin_name_'\\.")
317
class TestPlugins(BaseTestPlugins):
319
def setup_plugin(self, source=""):
320
# This test tests a new plugin appears in breezy.plugin.plugins().
321
# check the plugin is not loaded already
322
self.assertPluginUnknown('plugin')
323
# write a plugin that _cannot_ fail to load.
324
with open('plugin.py', 'w') as f:
325
f.write(source + '\n')
326
self.load_with_paths(['.'])
328
def test_plugin_loaded(self):
329
self.assertPluginUnknown('plugin')
330
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
332
p = breezy.plugin.get_loaded_plugin('plugin')
333
self.assertIsInstance(p, breezy.plugin.PlugIn)
334
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
336
def test_plugin_loaded_disabled(self):
337
self.assertPluginUnknown('plugin')
338
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
340
self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
342
def test_plugin_appears_in_plugins(self):
344
self.assertPluginKnown('plugin')
345
p = self.plugins['plugin']
346
self.assertIsInstance(p, breezy.plugin.PlugIn)
347
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
349
def test_trivial_plugin_get_path(self):
351
p = self.plugins['plugin']
352
plugin_path = self.test_dir + '/plugin.py'
353
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
355
def test_plugin_get_path_py_not_pyc(self):
356
# first import creates plugin.pyc
358
self.promote_cache(self.test_dir)
360
self.load_with_paths(['.']) # import plugin.pyc
361
p = plugin.plugins()['plugin']
362
plugin_path = self.test_dir + '/plugin.py'
363
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
365
def test_plugin_get_path_pyc_only(self):
366
# first import creates plugin.pyc (or plugin.pyo depending on __debug__)
368
os.unlink(self.test_dir + '/plugin.py')
369
self.promote_cache(self.test_dir)
371
self.load_with_paths(['.']) # import plugin.pyc (or .pyo)
372
p = plugin.plugins()['plugin']
373
plugin_path = self.test_dir + '/plugin' + plugin.COMPILED_EXT
374
self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
376
def test_no_test_suite_gives_None_for_test_suite(self):
378
p = plugin.plugins()['plugin']
379
self.assertEqual(None, p.test_suite())
381
def test_test_suite_gives_test_suite_result(self):
382
source = """def test_suite(): return 'foo'"""
383
self.setup_plugin(source)
384
p = plugin.plugins()['plugin']
385
self.assertEqual('foo', p.test_suite())
387
def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
389
loader = tests.TestUtil.TestLoader()
390
p = plugin.plugins()['plugin']
391
self.assertEqual(None, p.load_plugin_tests(loader))
393
def test_load_plugin_tests_gives_load_plugin_tests_result(self):
395
def load_tests(loader, standard_tests, pattern):
397
self.setup_plugin(source)
398
loader = tests.TestUtil.TestLoader()
399
p = plugin.plugins()['plugin']
400
self.assertEqual('foo', p.load_plugin_tests(loader))
402
def check_version_info(self, expected, source='', name='plugin'):
403
self.setup_plugin(source)
404
self.assertEqual(expected, plugin.plugins()[name].version_info())
406
def test_no_version_info(self):
407
self.check_version_info(None)
409
def test_with_version_info(self):
410
self.check_version_info((1, 2, 3, 'dev', 4),
411
"version_info = (1, 2, 3, 'dev', 4)")
413
def test_short_version_info_gets_padded(self):
414
# the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
416
self.check_version_info((1, 2, 3, 'final', 0),
417
"version_info = (1, 2, 3)")
419
def check_version(self, expected, source=None, name='plugin'):
420
self.setup_plugin(source)
421
self.assertEqual(expected, plugins[name].__version__)
423
def test_no_version_info___version__(self):
425
plugin = breezy.plugin.plugins()['plugin']
426
self.assertEqual("unknown", plugin.__version__)
428
def test_str__version__with_version_info(self):
429
self.setup_plugin("version_info = '1.2.3'")
430
plugin = breezy.plugin.plugins()['plugin']
431
self.assertEqual("1.2.3", plugin.__version__)
433
def test_noniterable__version__with_version_info(self):
434
self.setup_plugin("version_info = (1)")
435
plugin = breezy.plugin.plugins()['plugin']
436
self.assertEqual("1", plugin.__version__)
438
def test_1__version__with_version_info(self):
439
self.setup_plugin("version_info = (1,)")
440
plugin = breezy.plugin.plugins()['plugin']
441
self.assertEqual("1", plugin.__version__)
443
def test_1_2__version__with_version_info(self):
444
self.setup_plugin("version_info = (1, 2)")
445
plugin = breezy.plugin.plugins()['plugin']
446
self.assertEqual("1.2", plugin.__version__)
448
def test_1_2_3__version__with_version_info(self):
449
self.setup_plugin("version_info = (1, 2, 3)")
450
plugin = breezy.plugin.plugins()['plugin']
451
self.assertEqual("1.2.3", plugin.__version__)
453
def test_candidate__version__with_version_info(self):
454
self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
455
plugin = breezy.plugin.plugins()['plugin']
456
self.assertEqual("1.2.3rc1", plugin.__version__)
458
def test_dev__version__with_version_info(self):
459
self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
460
plugin = breezy.plugin.plugins()['plugin']
461
self.assertEqual("1.2.3dev", plugin.__version__)
463
def test_dev_fallback__version__with_version_info(self):
464
self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
465
plugin = breezy.plugin.plugins()['plugin']
466
self.assertEqual("1.2.3dev4", plugin.__version__)
468
def test_final__version__with_version_info(self):
469
self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
470
plugin = breezy.plugin.plugins()['plugin']
471
self.assertEqual("1.2.3", plugin.__version__)
473
def test_final_fallback__version__with_version_info(self):
474
self.setup_plugin("version_info = (1, 2, 3, 'final', 2)")
475
plugin = breezy.plugin.plugins()['plugin']
476
self.assertEqual("1.2.3.2", plugin.__version__)
479
class TestHelpIndex(tests.TestCase):
480
"""Tests for the PluginsHelpIndex class."""
482
def test_default_constructable(self):
483
index = plugin.PluginsHelpIndex()
485
def test_get_topics_None(self):
486
"""Searching for None returns an empty list."""
487
index = plugin.PluginsHelpIndex()
488
self.assertEqual([], index.get_topics(None))
490
def test_get_topics_for_plugin(self):
491
"""Searching for plugin name gets its docstring."""
492
index = plugin.PluginsHelpIndex()
493
# make a new plugin here for this test, even if we're run with
495
self.assertFalse('breezy.plugins.demo_module' in sys.modules)
496
demo_module = FakeModule('', 'breezy.plugins.demo_module')
497
sys.modules['breezy.plugins.demo_module'] = demo_module
499
topics = index.get_topics('demo_module')
500
self.assertEqual(1, len(topics))
501
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
502
self.assertEqual(demo_module, topics[0].module)
504
del sys.modules['breezy.plugins.demo_module']
506
def test_get_topics_no_topic(self):
507
"""Searching for something that is not a plugin returns []."""
508
# test this by using a name that cannot be a plugin - its not
509
# a valid python identifier.
510
index = plugin.PluginsHelpIndex()
511
self.assertEqual([], index.get_topics('nothing by this name'))
513
def test_prefix(self):
514
"""PluginsHelpIndex has a prefix of 'plugins/'."""
515
index = plugin.PluginsHelpIndex()
516
self.assertEqual('plugins/', index.prefix)
518
def test_get_plugin_topic_with_prefix(self):
519
"""Searching for plugins/demo_module returns help."""
520
index = plugin.PluginsHelpIndex()
521
self.assertFalse('breezy.plugins.demo_module' in sys.modules)
522
demo_module = FakeModule('', 'breezy.plugins.demo_module')
523
sys.modules['breezy.plugins.demo_module'] = demo_module
525
topics = index.get_topics('plugins/demo_module')
526
self.assertEqual(1, len(topics))
527
self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
528
self.assertEqual(demo_module, topics[0].module)
530
del sys.modules['breezy.plugins.demo_module']
533
class FakeModule(object):
534
"""A fake module to test with."""
536
def __init__(self, doc, name):
541
class TestModuleHelpTopic(tests.TestCase):
542
"""Tests for the ModuleHelpTopic class."""
544
def test_contruct(self):
545
"""Construction takes the module to document."""
546
mod = FakeModule('foo', 'foo')
547
topic = plugin.ModuleHelpTopic(mod)
548
self.assertEqual(mod, topic.module)
550
def test_get_help_text_None(self):
551
"""A ModuleHelpTopic returns the docstring for get_help_text."""
552
mod = FakeModule(None, 'demo')
553
topic = plugin.ModuleHelpTopic(mod)
554
self.assertEqual("Plugin 'demo' has no docstring.\n",
555
topic.get_help_text())
557
def test_get_help_text_no_carriage_return(self):
558
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
559
mod = FakeModule('one line of help', 'demo')
560
topic = plugin.ModuleHelpTopic(mod)
561
self.assertEqual("one line of help\n",
562
topic.get_help_text())
564
def test_get_help_text_carriage_return(self):
565
"""ModuleHelpTopic.get_help_text adds a \n if needed."""
566
mod = FakeModule('two lines of help\nand more\n', 'demo')
567
topic = plugin.ModuleHelpTopic(mod)
568
self.assertEqual("two lines of help\nand more\n",
569
topic.get_help_text())
571
def test_get_help_text_with_additional_see_also(self):
572
mod = FakeModule('two lines of help\nand more', 'demo')
573
topic = plugin.ModuleHelpTopic(mod)
575
"two lines of help\nand more\n\n:See also: bar, foo\n",
576
topic.get_help_text(['foo', 'bar']))
578
def test_get_help_topic(self):
579
"""The help topic for a plugin is its module name."""
580
mod = FakeModule('two lines of help\nand more', 'breezy.plugins.demo')
581
topic = plugin.ModuleHelpTopic(mod)
582
self.assertEqual('demo', topic.get_help_topic())
583
mod = FakeModule('two lines of help\nand more',
584
'breezy.plugins.foo_bar')
585
topic = plugin.ModuleHelpTopic(mod)
586
self.assertEqual('foo_bar', topic.get_help_topic())
589
class TestEnvPluginPath(tests.TestCase):
594
entrypoints = "ENTRYPOINTS"
596
def check_path(self, expected_dirs, setting_dirs):
597
if setting_dirs is None:
598
del os.environ['BRZ_PLUGIN_PATH']
600
os.environ['BRZ_PLUGIN_PATH'] = os.pathsep.join(setting_dirs)
601
actual = [(p if t == 'path' else t.upper())
602
for p, t in plugin._env_plugin_path()]
603
self.assertEqual(expected_dirs, actual)
605
def test_default(self):
606
self.check_path([self.user, self.core, self.site], None)
608
def test_adhoc_policy(self):
609
self.check_path([self.user, self.core, self.site],
610
['+user', '+core', '+site'])
612
def test_fallback_policy(self):
613
self.check_path([self.core, self.site, self.user],
614
['+core', '+site', '+user'])
616
def test_override_policy(self):
617
self.check_path([self.user, self.site, self.core],
618
['+user', '+site', '+core'])
620
def test_enable_entrypoints(self):
621
self.check_path([self.user, self.core, self.site, self.entrypoints],
622
['+user', '+core', '+site', '+entrypoints'])
624
def test_disable_user(self):
625
self.check_path([self.core, self.site], ['-user'])
627
def test_disable_user_twice(self):
628
# Ensures multiple removals don't left cruft
629
self.check_path([self.core, self.site], ['-user', '-user'])
631
def test_duplicates_are_removed(self):
632
self.check_path([self.user, self.core, self.site],
634
# And only the first reference is kept (since the later references will
635
# only produce '<plugin> already loaded' mutters)
636
self.check_path([self.user, self.core, self.site],
637
['+user', '+user', '+core',
638
'+user', '+site', '+site',
641
def test_disable_overrides_enable(self):
642
self.check_path([self.core, self.site], ['-user', '+user'])
644
def test_disable_core(self):
645
self.check_path([self.site], ['-core'])
646
self.check_path([self.user, self.site], ['+user', '-core'])
648
def test_disable_site(self):
649
self.check_path([self.core], ['-site'])
650
self.check_path([self.user, self.core], ['-site', '+user'])
652
def test_override_site(self):
653
self.check_path(['mysite', self.user, self.core],
654
['mysite', '-site', '+user'])
655
self.check_path(['mysite', self.core],
658
def test_override_core(self):
659
self.check_path(['mycore', self.user, self.site],
660
['mycore', '-core', '+user', '+site'])
661
self.check_path(['mycore', self.site],
664
def test_my_plugin_only(self):
667
['myplugin', '-user', '-core', '-site', '-entrypoints'])
669
def test_my_plugin_first(self):
670
self.check_path(['myplugin', self.core, self.site, self.user],
671
['myplugin', '+core', '+site', '+user'])
673
def test_bogus_references(self):
674
self.check_path(['+foo', '-bar', self.core, self.site],
678
class TestDisablePlugin(BaseTestPlugins):
680
def test_cannot_import(self):
681
self.create_plugin_package('works')
682
self.create_plugin_package('fails')
683
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'fails')
684
self.update_module_paths(["."])
685
import breezy.testingplugins.works as works
687
import breezy.testingplugins.fails as fails
691
self.fail("Loaded blocked plugin: " + repr(fails))
692
self.assertPluginModules({'fails': None, 'works': works})
694
def test_partial_imports(self):
695
self.create_plugin('good')
696
self.create_plugin('bad')
697
self.create_plugin_package('ugly')
698
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'bad:ugly')
699
self.load_with_paths(['.'])
700
self.assertEqual({'good'}, self.plugins.keys())
701
self.assertPluginModules({
702
'good': self.plugins['good'].module,
706
# Ensure there are no warnings about plugins not being imported as
707
# the user has explictly requested they be disabled.
708
self.assertNotContainsRe(self.get_log(), r"Unable to load plugin")
711
class TestEnvDisablePlugins(tests.TestCase):
713
def _get_names(self, env_value):
714
os.environ['BRZ_DISABLE_PLUGINS'] = env_value
715
return plugin._env_disable_plugins()
717
def test_unset(self):
718
self.assertEqual([], plugin._env_disable_plugins())
720
def test_empty(self):
721
self.assertEqual([], self._get_names(''))
723
def test_single(self):
724
self.assertEqual(['single'], self._get_names('single'))
726
def test_multi(self):
727
expected = ['one', 'two']
728
self.assertEqual(expected, self._get_names(os.pathsep.join(expected)))
730
def test_mixed(self):
731
value = os.pathsep.join(['valid', 'in-valid'])
732
self.assertEqual(['valid'], self._get_names(value))
733
self.assertContainsRe(
735
r"Invalid name 'in-valid' in BRZ_DISABLE_PLUGINS=" + repr(value))
738
class TestEnvPluginsAt(tests.TestCase):
740
def _get_paths(self, env_value):
741
os.environ['BRZ_PLUGINS_AT'] = env_value
742
return plugin._env_plugins_at()
744
def test_empty(self):
745
self.assertEqual([], plugin._env_plugins_at())
746
self.assertEqual([], self._get_paths(''))
748
def test_one_path(self):
749
self.assertEqual([('b', 'man')], self._get_paths('b@man'))
751
def test_multiple(self):
753
[('tools', 'bzr-tools'), ('p', 'play.py')],
754
self._get_paths(os.pathsep.join(('tools@bzr-tools', 'p@play.py'))))
756
def test_many_at(self):
758
[('church', 'StMichael@Plea@Norwich')],
759
self._get_paths('church@StMichael@Plea@Norwich'))
761
def test_only_py(self):
762
self.assertEqual([('test', './test.py')], self._get_paths('./test.py'))
764
def test_only_package(self):
765
self.assertEqual([('py', '/opt/b/py')], self._get_paths('/opt/b/py'))
767
def test_bad_name(self):
768
self.assertEqual([], self._get_paths('/usr/local/bzr-git'))
769
self.assertContainsRe(
771
r"Invalid name 'bzr-git' in BRZ_PLUGINS_AT='/usr/local/bzr-git'")
774
class TestLoadPluginAt(BaseTestPlugins):
777
super(TestLoadPluginAt, self).setUp()
778
# Create the same plugin in two directories
779
self.create_plugin_package('test_foo', dir='non-standard-dir')
780
# The "normal" directory, we use 'standard' instead of 'plugins' to
781
# avoid depending on the precise naming.
782
self.create_plugin_package('test_foo', dir='standard/test_foo')
784
def assertTestFooLoadedFrom(self, path):
785
self.assertPluginKnown('test_foo')
786
self.assertDocstring('This is the doc for test_foo',
787
self.module.test_foo)
788
self.assertEqual(path, self.module.test_foo.dir_source)
790
def test_regular_load(self):
791
self.load_with_paths(['standard'])
792
self.assertTestFooLoadedFrom('standard/test_foo')
794
def test_import(self):
795
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
796
self.update_module_paths(['standard'])
797
import breezy.testingplugins.test_foo
798
self.assertTestFooLoadedFrom('non-standard-dir')
800
def test_loading(self):
801
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
802
self.load_with_paths(['standard'])
803
self.assertTestFooLoadedFrom('non-standard-dir')
805
def test_loading_other_name(self):
806
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
807
os.rename('standard/test_foo', 'standard/test_bar')
808
self.load_with_paths(['standard'])
809
self.assertTestFooLoadedFrom('non-standard-dir')
811
def test_compiled_loaded(self):
812
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
813
self.load_with_paths(['standard'])
814
self.assertTestFooLoadedFrom('non-standard-dir')
815
self.assertIsSameRealPath('non-standard-dir/__init__.py',
816
self.module.test_foo.__file__)
818
# Try importing again now that the source has been compiled
819
os.remove('non-standard-dir/__init__.py')
820
self.promote_cache('non-standard-dir')
822
self.load_with_paths(['standard'])
823
self.assertTestFooLoadedFrom('non-standard-dir')
824
suffix = plugin.COMPILED_EXT
825
self.assertIsSameRealPath('non-standard-dir/__init__' + suffix,
826
self.module.test_foo.__file__)
828
def test_submodule_loading(self):
829
# We create an additional directory under the one for test_foo
830
self.create_plugin_package('test_bar', dir='non-standard-dir/test_bar')
831
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
832
self.update_module_paths(['standard'])
833
import breezy.testingplugins.test_foo # noqa: F401
834
self.assertEqual(self.module_prefix + 'test_foo',
835
self.module.test_foo.__package__)
836
import breezy.testingplugins.test_foo.test_bar # noqa: F401
837
self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
838
self.module.test_foo.test_bar.__file__)
840
def test_relative_submodule_loading(self):
841
self.create_plugin_package('test_foo', dir='another-dir', source='''
842
from . import test_bar
844
# We create an additional directory under the one for test_foo
845
self.create_plugin_package('test_bar', dir='another-dir/test_bar')
846
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@another-dir')
847
self.update_module_paths(['standard'])
848
import breezy.testingplugins.test_foo # noqa: F401
849
self.assertEqual(self.module_prefix + 'test_foo',
850
self.module.test_foo.__package__)
851
self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
852
self.module.test_foo.test_bar.__file__)
854
def test_loading_from___init__only(self):
855
# We rename the existing __init__.py file to ensure that we don't load
857
init = 'non-standard-dir/__init__.py'
858
random = 'non-standard-dir/setup.py'
859
os.rename(init, random)
860
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
861
self.load_with_paths(['standard'])
862
self.assertPluginUnknown('test_foo')
864
def test_loading_from_specific_file(self):
865
plugin_dir = 'non-standard-dir'
866
plugin_file_name = 'iamtestfoo.py'
867
plugin_path = osutils.pathjoin(plugin_dir, plugin_file_name)
869
"""This is the doc for %s"""
871
''' % ('test_foo', plugin_path)
872
self.create_plugin('test_foo', source=source,
873
dir=plugin_dir, file_name=plugin_file_name)
874
self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@%s' % plugin_path)
875
self.load_with_paths(['standard'])
876
self.assertTestFooLoadedFrom(plugin_path)
879
class TestDescribePlugins(BaseTestPlugins):
881
def test_describe_plugins(self):
882
class DummyModule(object):
885
class DummyPlugin(object):
886
__version__ = '0.1.0'
887
module = DummyModule()
888
self.plugin_warnings = {'bad': ['Failed to load (just testing)']}
889
self.plugins = {'good': DummyPlugin()}
890
self.assertEqual("""\
892
** Failed to load (just testing)
897
""", ''.join(plugin.describe_plugins(state=self)))
900
class DummyPlugin(object):
904
class TestLoadEnvPlugin(BaseTestPlugins):
906
_test_needs_features = [pkg_resources_feature]
908
def setup_plugin(self, source=""):
909
# This test tests a new plugin appears in breezy.plugin.plugins().
910
# check the plugin is not loaded already
911
self.assertPluginUnknown('plugin')
912
# write a plugin that _cannot_ fail to load.
914
d = pkg_resources.Distribution(__file__)
915
ep = pkg_resources.EntryPoint.parse(
916
'plugin = ' + __name__ + ':DummyPlugin', dist=d)
917
d._ep_map = {'breezy.plugin': {'plugin': ep}}
918
pkg_resources.working_set.add(d, 'plugin', replace=True)
919
eps = list(pkg_resources.iter_entry_points('breezy.plugin'))
920
self.assertEqual(['plugin'], [ep.name for ep in eps])
921
self.load_with_paths(['.'])
922
self.addCleanup(d._ep_map.clear)
924
def test_plugin_loaded(self):
925
self.assertPluginUnknown('plugin')
926
self.overrideEnv('BRZ_PLUGIN_PATH', '+entrypoints')
928
p = self.plugins['plugin']
929
self.assertIsInstance(p, breezy.plugin.PlugIn)
930
self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
932
def test_plugin_loaded_disabled(self):
933
self.assertPluginUnknown('plugin')
934
self.overrideEnv('BRZ_PLUGIN_PATH', '+entrypoints')
935
self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
937
self.assertNotIn('plugin', self.plugins)
added
removed
breezy/tests/test_plugins.py
