/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_plugins.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-03-25 11:54:30 UTC
  • mfrom: (6855.4.10 more-bees)
  • Revision ID: breezy.the.bot@gmail.com-20180325115430-75xnlbrmzjoomd83
Add more bees. In particular:

* for file ids
* for revision ids
* for file contents in build_tree_contents()

Merged from https://code.launchpad.net/~jelmer/brz/more-bees/+merge/337919

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_plugins.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 Canonical Ltd, 2017 Breezy developers
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for plugins"""
18
18
 
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
21
 
# comments.
22
 
 
23
 
from cStringIO import StringIO
 
19
try:
 
20
    from importlib.util import module_from_spec
 
21
except ImportError:  # python < 3
 
22
    from imp import new_module as module_from_spec
 
23
import importlib
24
24
import logging
25
25
import os
26
26
import sys
27
27
 
28
 
import bzrlib
29
 
from bzrlib import (
 
28
import breezy
 
29
from .. import (
 
30
    errors,
30
31
    osutils,
31
32
    plugin,
32
 
    plugins,
33
33
    tests,
34
34
    trace,
35
35
    )
 
36
from ..sixish import (
 
37
    PY3,
 
38
    StringIO,
 
39
    viewkeys,
 
40
    )
36
41
 
37
42
 
38
43
# TODO: Write a test for plugin decoration of commands.
39
44
 
40
 
class TestPluginMixin(object):
 
45
invalidate_caches = getattr(importlib, "invalidate_caches", lambda: None)
 
46
 
 
47
 
 
48
class BaseTestPlugins(tests.TestCaseInTempDir):
 
49
    """TestCase that isolates plugin imports and cleans up on completion."""
 
50
 
 
51
    def setUp(self):
 
52
        super(BaseTestPlugins, self).setUp()
 
53
        self.module_name = "breezy.testingplugins"
 
54
        self.module_prefix = self.module_name + "."
 
55
        self.module = module_from_spec(self.module_name)
 
56
 
 
57
        self.overrideAttr(plugin, "_MODULE_PREFIX", self.module_prefix)
 
58
        self.overrideAttr(breezy, "testingplugins", self.module)
 
59
 
 
60
        sys.modules[self.module_name] = self.module
 
61
        self.addCleanup(self._unregister_all)
 
62
        self.addCleanup(self._unregister_finder)
 
63
 
 
64
        invalidate_caches()
 
65
 
 
66
    def reset(self):
 
67
        """Remove all global testing state and clean up module."""
 
68
        # GZ 2017-06-02: Ideally don't do this, write new test or generate
 
69
        # bytecode by other mechanism.
 
70
        self.log("resetting plugin testing context")
 
71
        self._unregister_all()
 
72
        self._unregister_finder()
 
73
        sys.modules[self.module_name] = self.module
 
74
        for name in list(self.module.__dict__):
 
75
            if name[:2] != '__':
 
76
                delattr(self.module, name)
 
77
        invalidate_caches()
 
78
        self.plugins = None
 
79
 
 
80
    def update_module_paths(self, paths):
 
81
        paths = plugin.extend_path(paths, self.module_name)
 
82
        self.module.__path__ = paths
 
83
        self.log("using %r", paths)
 
84
        return paths
 
85
 
 
86
    def load_with_paths(self, paths):
 
87
        self.log("loading plugins!")
 
88
        plugin.load_plugins(self.update_module_paths(paths), state=self)
41
89
 
42
90
    def create_plugin(self, name, source=None, dir='.', file_name=None):
43
91
        if source is None:
48
96
            file_name = name + '.py'
49
97
        # 'source' must not fail to load
50
98
        path = osutils.pathjoin(dir, file_name)
51
 
        f = open(path, 'w')
52
 
        self.addCleanup(os.unlink, path)
53
 
        try:
 
99
        with open(path, 'w') as f:
54
100
            f.write(source + '\n')
55
 
        finally:
56
 
            f.close()
57
101
 
58
102
    def create_plugin_package(self, name, dir=None, source=None):
59
103
        if dir is None:
64
108
dir_source = '%s'
65
109
''' % (name, dir)
66
110
        os.makedirs(dir)
67
 
        def cleanup():
68
 
            # Workaround lazy import random? madness
69
 
            osutils.rmtree(dir)
70
 
        self.addCleanup(cleanup)
71
111
        self.create_plugin(name, source, dir,
72
112
                           file_name='__init__.py')
73
113
 
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)
 
114
    def promote_cache(self, directory):
 
115
        """Move bytecode files out of __pycache__ in given directory."""
 
116
        cache_dir = os.path.join(directory, '__pycache__')
 
117
        if os.path.isdir(cache_dir):
 
118
            for name in os.listdir(cache_dir):
 
119
                magicless_name = '.'.join(name.split('.')[0::name.count('.')])
 
120
                rel = osutils.relpath(self.test_dir, cache_dir)
 
121
                self.log("moving %s in %s to %s", name, rel, magicless_name)
 
122
                os.rename(os.path.join(cache_dir, name),
 
123
                    os.path.join(directory, magicless_name))
 
124
 
 
125
    def _unregister_finder(self):
 
126
        """Removes any test copies of _PluginsAtFinder from sys.meta_path."""
 
127
        idx = len(sys.meta_path)
 
128
        while idx:
 
129
            idx -= 1
 
130
            finder = sys.meta_path[idx]
 
131
            if getattr(finder, "prefix", "") == self.module_prefix:
 
132
                self.log("removed %r from sys.meta_path", finder)
 
133
                sys.meta_path.pop(idx)
 
134
 
 
135
    def _unregister_all(self):
 
136
        """Remove all plugins in the test namespace from sys.modules."""
 
137
        for name in list(sys.modules):
 
138
            if name.startswith(self.module_prefix) or name == self.module_name:
 
139
                self.log("removed %s from sys.modules", name)
 
140
                del sys.modules[name]
 
141
 
 
142
    def assertPluginModules(self, plugin_dict):
 
143
        self.assertEqual(
 
144
            dict((k[len(self.module_prefix):], sys.modules[k])
 
145
                for k in sys.modules if k.startswith(self.module_prefix)),
 
146
            plugin_dict)
81
147
 
82
148
    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)
 
149
        self.assertTrue(getattr(self.module, name, None) is None)
 
150
        self.assertFalse(self.module_prefix + name in sys.modules)
85
151
 
86
152
    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)
89
 
 
90
 
 
91
 
class TestLoadingPlugins(tests.TestCaseInTempDir, TestPluginMixin):
 
153
        self.assertTrue(getattr(self.module, name, None) is not None)
 
154
        self.assertTrue(self.module_prefix + name in sys.modules)
 
155
 
 
156
 
 
157
class TestLoadingPlugins(BaseTestPlugins):
92
158
 
93
159
    activeattributes = {}
94
160
 
98
164
        # file name we can use which is also a valid attribute for accessing in
99
165
        # activeattributes. - we cannot give import parameters.
100
166
        tempattribute = "0"
101
 
        self.failIf(tempattribute in self.activeattributes)
 
167
        self.assertFalse(tempattribute in self.activeattributes)
102
168
        # set a place for the plugins to record their loading, and at the same
103
169
        # time validate that the location the plugins should record to is
104
170
        # valid and correct.
105
171
        self.__class__.activeattributes [tempattribute] = []
106
 
        self.failUnless(tempattribute in self.activeattributes)
 
172
        self.assertTrue(tempattribute in self.activeattributes)
107
173
        # create two plugin directories
108
174
        os.mkdir('first')
109
175
        os.mkdir('second')
110
176
        # write a plugin that will record when its loaded in the
111
177
        # tempattribute list.
112
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
178
        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
113
179
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
114
180
 
115
 
        outfile = open(os.path.join('first', 'plugin.py'), 'w')
116
 
        try:
 
181
        with open(os.path.join('first', 'plugin.py'), 'w') as outfile:
117
182
            outfile.write(template % (tempattribute, 'first'))
118
183
            outfile.write('\n')
119
 
        finally:
120
 
            outfile.close()
121
184
 
122
 
        outfile = open(os.path.join('second', 'plugin.py'), 'w')
123
 
        try:
 
185
        with open(os.path.join('second', 'plugin.py'), 'w') as outfile:
124
186
            outfile.write(template % (tempattribute, 'second'))
125
187
            outfile.write('\n')
126
 
        finally:
127
 
            outfile.close()
128
188
 
129
189
        try:
130
 
            bzrlib.plugin.load_from_path(['first', 'second'])
 
190
            self.load_with_paths(['first', 'second'])
131
191
            self.assertEqual(['first'], self.activeattributes[tempattribute])
132
192
        finally:
133
 
            # remove the plugin 'plugin'
134
193
            del self.activeattributes[tempattribute]
135
 
            self._unregister_plugin('plugin')
136
 
        self.assertPluginUnknown('plugin')
137
194
 
138
195
    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)
 
196
        self.assertFalse('breezy.plugins.pluginone' in sys.modules)
 
197
        self.assertFalse('breezy.plugins.plugintwo' in sys.modules)
141
198
        # This test tests that having two plugins in different
142
199
        # directories with different names allows them both to be loaded, when
143
200
        # we do a direct import statement.
144
201
        # Determine a file name we can use which is also a valid attribute
145
202
        # for accessing in activeattributes. - we cannot give import parameters.
146
203
        tempattribute = "different-dirs"
147
 
        self.failIf(tempattribute in self.activeattributes)
 
204
        self.assertFalse(tempattribute in self.activeattributes)
148
205
        # set a place for the plugins to record their loading, and at the same
149
206
        # time validate that the location the plugins should record to is
150
207
        # valid and correct.
151
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
208
        breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \
152
209
            [tempattribute] = []
153
 
        self.failUnless(tempattribute in self.activeattributes)
 
210
        self.assertTrue(tempattribute in self.activeattributes)
154
211
        # create two plugin directories
155
212
        os.mkdir('first')
156
213
        os.mkdir('second')
157
214
        # write plugins that will record when they are loaded in the
158
215
        # tempattribute list.
159
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
216
        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
160
217
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
161
218
 
162
 
        outfile = open(os.path.join('first', 'pluginone.py'), 'w')
163
 
        try:
 
219
        with open(os.path.join('first', 'pluginone.py'), 'w') as outfile:
164
220
            outfile.write(template % (tempattribute, 'first'))
165
221
            outfile.write('\n')
166
 
        finally:
167
 
            outfile.close()
168
222
 
169
 
        outfile = open(os.path.join('second', 'plugintwo.py'), 'w')
170
 
        try:
 
223
        with open(os.path.join('second', 'plugintwo.py'), 'w') as outfile:
171
224
            outfile.write(template % (tempattribute, 'second'))
172
225
            outfile.write('\n')
173
 
        finally:
174
 
            outfile.close()
175
226
 
176
 
        oldpath = bzrlib.plugins.__path__
177
227
        try:
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"
 
228
            self.assertPluginUnknown('pluginone')
 
229
            self.assertPluginUnknown('plugintwo')
 
230
            self.update_module_paths(['first', 'second'])
 
231
            exec("import %spluginone" % self.module_prefix)
182
232
            self.assertEqual(['first'], self.activeattributes[tempattribute])
183
 
            exec "import bzrlib.plugins.plugintwo"
 
233
            exec("import %splugintwo" % self.module_prefix)
184
234
            self.assertEqual(['first', 'second'],
185
235
                self.activeattributes[tempattribute])
186
236
        finally:
187
 
            # remove the plugin 'plugin'
188
237
            del self.activeattributes[tempattribute]
189
 
            self._unregister_plugin('pluginone')
190
 
            self._unregister_plugin('plugintwo')
191
 
        self.assertPluginUnknown('pluginone')
192
 
        self.assertPluginUnknown('plugintwo')
193
238
 
194
239
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
195
240
        # This test tests that a plugin can load from a directory when the
197
242
        # check the plugin is not loaded already
198
243
        self.assertPluginUnknown('ts_plugin')
199
244
        tempattribute = "trailing-slash"
200
 
        self.failIf(tempattribute in self.activeattributes)
 
245
        self.assertFalse(tempattribute in self.activeattributes)
201
246
        # set a place for the plugin to record its loading, and at the same
202
247
        # time validate that the location the plugin should record to is
203
248
        # valid and correct.
204
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
 
249
        breezy.tests.test_plugins.TestLoadingPlugins.activeattributes \
205
250
            [tempattribute] = []
206
 
        self.failUnless(tempattribute in self.activeattributes)
 
251
        self.assertTrue(tempattribute in self.activeattributes)
207
252
        # create a directory for the plugin
208
253
        os.mkdir('plugin_test')
209
254
        # write a plugin that will record when its loaded in the
210
255
        # tempattribute list.
211
 
        template = ("from bzrlib.tests.test_plugins import TestLoadingPlugins\n"
 
256
        template = ("from breezy.tests.test_plugins import TestLoadingPlugins\n"
212
257
                    "TestLoadingPlugins.activeattributes[%r].append('%s')\n")
213
258
 
214
 
        outfile = open(os.path.join('plugin_test', 'ts_plugin.py'), 'w')
215
 
        try:
 
259
        with open(os.path.join('plugin_test', 'ts_plugin.py'), 'w') as outfile:
216
260
            outfile.write(template % (tempattribute, 'plugin'))
217
261
            outfile.write('\n')
218
 
        finally:
219
 
            outfile.close()
220
262
 
221
263
        try:
222
 
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
 
264
            self.load_with_paths(['plugin_test'+os.sep])
223
265
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
 
266
            self.assertPluginKnown('ts_plugin')
224
267
        finally:
225
268
            del self.activeattributes[tempattribute]
226
 
            self._unregister_plugin('ts_plugin')
227
 
        self.assertPluginUnknown('ts_plugin')
228
269
 
229
270
    def load_and_capture(self, name):
230
271
        """Load plugins from '.' capturing the output.
236
277
        stream = StringIO()
237
278
        try:
238
279
            handler = logging.StreamHandler(stream)
239
 
            log = logging.getLogger('bzr')
 
280
            log = logging.getLogger('brz')
240
281
            log.addHandler(handler)
241
282
            try:
242
 
                try:
243
 
                    bzrlib.plugin.load_from_path(['.'])
244
 
                finally:
245
 
                    if 'bzrlib.plugins.%s' % name in sys.modules:
246
 
                        del sys.modules['bzrlib.plugins.%s' % name]
247
 
                    if getattr(bzrlib.plugins, name, None):
248
 
                        delattr(bzrlib.plugins, name)
 
283
                self.load_with_paths(['.'])
249
284
            finally:
250
285
                # Stop capturing output
251
286
                handler.flush()
256
291
            stream.close()
257
292
 
258
293
    def test_plugin_with_bad_api_version_reports(self):
259
 
        # This plugin asks for bzrlib api version 1.0.0, which is not supported
260
 
        # anymore.
 
294
        """Try loading a plugin that requests an unsupported api.
 
295
 
 
296
        Observe that it records the problem but doesn't complain on stderr.
 
297
 
 
298
        See https://bugs.launchpad.net/bzr/+bug/704195
 
299
        """
261
300
        name = 'wants100.py'
262
 
        f = file(name, 'w')
263
 
        try:
264
 
            f.write("import bzrlib.api\n"
265
 
                "bzrlib.api.require_any_api(bzrlib, [(1, 0, 0)])\n")
266
 
        finally:
267
 
            f.close()
268
 
 
 
301
        with open(name, 'w') as f:
 
302
            f.write("import breezy\n"
 
303
                "from breezy.errors import IncompatibleVersion\n"
 
304
                "raise IncompatibleVersion(breezy, [(1, 0, 0)], (0, 0, 5))\n")
269
305
        log = self.load_and_capture(name)
270
 
        self.assertContainsRe(log,
271
 
            r"It requested API version")
 
306
        self.assertNotContainsRe(log,
 
307
            r"It supports breezy version")
 
308
        self.assertEqual({'wants100'}, viewkeys(self.plugin_warnings))
 
309
        self.assertContainsRe(
 
310
            self.plugin_warnings['wants100'][0],
 
311
            r"It supports breezy version")
272
312
 
273
313
    def test_plugin_with_bad_name_does_not_load(self):
274
314
        # The file name here invalid for a python module.
275
 
        name = 'bzr-bad plugin-name..py'
276
 
        file(name, 'w').close()
 
315
        name = 'brz-bad plugin-name..py'
 
316
        open(name, 'w').close()
277
317
        log = self.load_and_capture(name)
278
318
        self.assertContainsRe(log,
279
 
            r"Unable to load 'bzr-bad plugin-name\.' in '\.' as a plugin "
 
319
            r"Unable to load 'brz-bad plugin-name\.' in '\.' as a plugin "
280
320
            "because the file path isn't a valid module name; try renaming "
281
 
            "it to 'bad_plugin_name_'\.")
282
 
 
283
 
 
284
 
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
 
321
            "it to 'bad_plugin_name_'\\.")
 
322
 
 
323
 
 
324
class TestPlugins(BaseTestPlugins):
285
325
 
286
326
    def setup_plugin(self, source=""):
287
 
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
 
327
        # This test tests a new plugin appears in breezy.plugin.plugins().
288
328
        # check the plugin is not loaded already
289
329
        self.assertPluginUnknown('plugin')
290
330
        # 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(['.'])
294
 
 
295
 
    def teardown_plugin(self):
296
 
        self._unregister_plugin('plugin')
297
 
        self.assertPluginUnknown('plugin')
 
331
        with open('plugin.py', 'w') as f: f.write(source + '\n')
 
332
        self.load_with_paths(['.'])
 
333
 
 
334
    def test_plugin_loaded(self):
 
335
        self.assertPluginUnknown('plugin')
 
336
        self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
 
337
        self.setup_plugin()
 
338
        p = breezy.plugin.get_loaded_plugin('plugin')
 
339
        self.assertIsInstance(p, breezy.plugin.PlugIn)
 
340
        self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
 
341
 
 
342
    def test_plugin_loaded_disabled(self):
 
343
        self.assertPluginUnknown('plugin')
 
344
        self.overrideEnv('BRZ_DISABLE_PLUGINS', 'plugin')
 
345
        self.setup_plugin()
 
346
        self.assertIs(None, breezy.plugin.get_loaded_plugin('plugin'))
298
347
 
299
348
    def test_plugin_appears_in_plugins(self):
300
349
        self.setup_plugin()
301
350
        self.assertPluginKnown('plugin')
302
 
        p = plugin.plugins()['plugin']
303
 
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
304
 
        self.assertEqual(p.module, plugins.plugin)
 
351
        p = self.plugins['plugin']
 
352
        self.assertIsInstance(p, breezy.plugin.PlugIn)
 
353
        self.assertIs(p.module, sys.modules[self.module_prefix + 'plugin'])
305
354
 
306
355
    def test_trivial_plugin_get_path(self):
307
356
        self.setup_plugin()
308
 
        p = plugin.plugins()['plugin']
 
357
        p = self.plugins['plugin']
309
358
        plugin_path = self.test_dir + '/plugin.py'
310
359
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
311
360
 
312
361
    def test_plugin_get_path_py_not_pyc(self):
313
362
        # first import creates plugin.pyc
314
363
        self.setup_plugin()
315
 
        self.teardown_plugin()
316
 
        plugin.load_from_path(['.']) # import plugin.pyc
 
364
        self.promote_cache(self.test_dir)
 
365
        self.reset()
 
366
        self.load_with_paths(['.']) # import plugin.pyc
317
367
        p = plugin.plugins()['plugin']
318
368
        plugin_path = self.test_dir + '/plugin.py'
319
369
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
321
371
    def test_plugin_get_path_pyc_only(self):
322
372
        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)
323
373
        self.setup_plugin()
324
 
        self.teardown_plugin()
325
374
        os.unlink(self.test_dir + '/plugin.py')
326
 
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
375
        self.promote_cache(self.test_dir)
 
376
        self.reset()
 
377
        self.load_with_paths(['.']) # import plugin.pyc (or .pyo)
327
378
        p = plugin.plugins()['plugin']
328
 
        if __debug__:
329
 
            plugin_path = self.test_dir + '/plugin.pyc'
330
 
        else:
331
 
            plugin_path = self.test_dir + '/plugin.pyo'
 
379
        plugin_path = self.test_dir + '/plugin' + plugin.COMPILED_EXT
332
380
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
333
381
 
334
382
    def test_no_test_suite_gives_None_for_test_suite(self):
350
398
 
351
399
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
352
400
        source = """
353
 
def load_tests(standard_tests, module, loader):
 
401
def load_tests(loader, standard_tests, pattern):
354
402
    return 'foo'"""
355
403
        self.setup_plugin(source)
356
404
        loader = tests.TestUtil.TestLoader()
380
428
 
381
429
    def test_no_version_info___version__(self):
382
430
        self.setup_plugin()
383
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
431
        plugin = breezy.plugin.plugins()['plugin']
384
432
        self.assertEqual("unknown", plugin.__version__)
385
433
 
386
434
    def test_str__version__with_version_info(self):
387
435
        self.setup_plugin("version_info = '1.2.3'")
388
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
436
        plugin = breezy.plugin.plugins()['plugin']
389
437
        self.assertEqual("1.2.3", plugin.__version__)
390
438
 
391
439
    def test_noniterable__version__with_version_info(self):
392
440
        self.setup_plugin("version_info = (1)")
393
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
441
        plugin = breezy.plugin.plugins()['plugin']
394
442
        self.assertEqual("1", plugin.__version__)
395
443
 
396
444
    def test_1__version__with_version_info(self):
397
445
        self.setup_plugin("version_info = (1,)")
398
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
446
        plugin = breezy.plugin.plugins()['plugin']
399
447
        self.assertEqual("1", plugin.__version__)
400
448
 
401
449
    def test_1_2__version__with_version_info(self):
402
450
        self.setup_plugin("version_info = (1, 2)")
403
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
451
        plugin = breezy.plugin.plugins()['plugin']
404
452
        self.assertEqual("1.2", plugin.__version__)
405
453
 
406
454
    def test_1_2_3__version__with_version_info(self):
407
455
        self.setup_plugin("version_info = (1, 2, 3)")
408
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
456
        plugin = breezy.plugin.plugins()['plugin']
409
457
        self.assertEqual("1.2.3", plugin.__version__)
410
458
 
411
459
    def test_candidate__version__with_version_info(self):
412
460
        self.setup_plugin("version_info = (1, 2, 3, 'candidate', 1)")
413
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
461
        plugin = breezy.plugin.plugins()['plugin']
414
462
        self.assertEqual("1.2.3rc1", plugin.__version__)
415
463
 
416
464
    def test_dev__version__with_version_info(self):
417
465
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 0)")
418
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
466
        plugin = breezy.plugin.plugins()['plugin']
419
467
        self.assertEqual("1.2.3dev", plugin.__version__)
420
468
 
421
469
    def test_dev_fallback__version__with_version_info(self):
422
470
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
423
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
471
        plugin = breezy.plugin.plugins()['plugin']
424
472
        self.assertEqual("1.2.3dev4", plugin.__version__)
425
473
 
426
474
    def test_final__version__with_version_info(self):
427
475
        self.setup_plugin("version_info = (1, 2, 3, 'final', 0)")
428
 
        plugin = bzrlib.plugin.plugins()['plugin']
 
476
        plugin = breezy.plugin.plugins()['plugin']
429
477
        self.assertEqual("1.2.3", plugin.__version__)
430
478
 
431
479
    def test_final_fallback__version__with_version_info(self):
432
480
        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__)
435
 
 
436
 
 
437
 
class TestPluginHelp(tests.TestCaseInTempDir):
 
481
        plugin = breezy.plugin.plugins()['plugin']
 
482
        self.assertEqual("1.2.3.2", plugin.__version__)
 
483
 
 
484
 
 
485
# GZ 2017-06-02: Move this suite to blackbox, as it's what it actually is.
 
486
class TestPluginHelp(BaseTestPlugins):
438
487
 
439
488
    def split_help_commands(self):
440
489
        help = {}
450
499
    def test_plugin_help_builtins_unaffected(self):
451
500
        # Check we don't get false positives
452
501
        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():
 
502
        for cmd_name in breezy.commands.builtin_command_names():
 
503
            if cmd_name in breezy.commands.plugin_command_names():
455
504
                continue
456
505
            try:
457
 
                help = bzrlib.commands.get_cmd_object(cmd_name).get_help_text()
 
506
                help = breezy.commands.get_cmd_object(cmd_name).get_help_text()
458
507
            except NotImplementedError:
459
508
                # some commands have no help
460
509
                pass
461
510
            else:
462
511
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
463
512
 
464
 
            if cmd_name in help_commands.keys():
 
513
            if cmd_name in help_commands:
465
514
                # some commands are hidden
466
515
                help = help_commands[cmd_name]
467
516
                self.assertNotContainsRe(help, 'plugin "[^"]*"')
469
518
    def test_plugin_help_shows_plugin(self):
470
519
        # Create a test plugin
471
520
        os.mkdir('plugin_test')
472
 
        f = open(osutils.pathjoin('plugin_test', 'myplug.py'), 'w')
473
 
        f.write("""\
474
 
from bzrlib import commands
475
 
class cmd_myplug(commands.Command):
476
 
    __doc__ = '''Just a simple test plugin.'''
477
 
    aliases = ['mplg']
478
 
    def run(self):
479
 
        print 'Hello from my plugin'
480
 
 
481
 
"""
482
 
)
483
 
        f.close()
484
 
 
485
 
        try:
486
 
            # Check its help
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\]')
493
 
        finally:
494
 
            # unregister command
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')
 
521
        source = (
 
522
            "from breezy import commands\n"
 
523
            "class cmd_myplug(commands.Command):\n"
 
524
            "    __doc__ = '''Just a simple test plugin.'''\n"
 
525
            "    aliases = ['mplg']\n"
 
526
            "    def run(self):\n"
 
527
            "        print ('Hello from my plugin')\n"
 
528
        )
 
529
        self.create_plugin('myplug', source, 'plugin_test')
 
530
 
 
531
        # Check its help
 
532
        self.load_with_paths(['plugin_test'])
 
533
        myplug = self.plugins['myplug'].module
 
534
        breezy.commands.register_command(myplug.cmd_myplug)
 
535
        self.addCleanup(breezy.commands.plugin_cmds.remove, 'myplug')
 
536
        help = self.run_bzr('help myplug')[0]
 
537
        self.assertContainsRe(help, 'plugin "myplug"')
 
538
        help = self.split_help_commands()['myplug']
 
539
        self.assertContainsRe(help, '\\[myplug\\]')
500
540
 
501
541
 
502
542
class TestHelpIndex(tests.TestCase):
515
555
        index = plugin.PluginsHelpIndex()
516
556
        # make a new plugin here for this test, even if we're run with
517
557
        # --no-plugins
518
 
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
519
 
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
520
 
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
558
        self.assertFalse('breezy.plugins.demo_module' in sys.modules)
 
559
        demo_module = FakeModule('', 'breezy.plugins.demo_module')
 
560
        sys.modules['breezy.plugins.demo_module'] = demo_module
521
561
        try:
522
562
            topics = index.get_topics('demo_module')
523
563
            self.assertEqual(1, len(topics))
524
564
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
525
565
            self.assertEqual(demo_module, topics[0].module)
526
566
        finally:
527
 
            del sys.modules['bzrlib.plugins.demo_module']
 
567
            del sys.modules['breezy.plugins.demo_module']
528
568
 
529
569
    def test_get_topics_no_topic(self):
530
570
        """Searching for something that is not a plugin returns []."""
541
581
    def test_get_plugin_topic_with_prefix(self):
542
582
        """Searching for plugins/demo_module returns help."""
543
583
        index = plugin.PluginsHelpIndex()
544
 
        self.assertFalse(sys.modules.has_key('bzrlib.plugins.demo_module'))
545
 
        demo_module = FakeModule('', 'bzrlib.plugins.demo_module')
546
 
        sys.modules['bzrlib.plugins.demo_module'] = demo_module
 
584
        self.assertFalse('breezy.plugins.demo_module' in sys.modules)
 
585
        demo_module = FakeModule('', 'breezy.plugins.demo_module')
 
586
        sys.modules['breezy.plugins.demo_module'] = demo_module
547
587
        try:
548
588
            topics = index.get_topics('plugins/demo_module')
549
589
            self.assertEqual(1, len(topics))
550
590
            self.assertIsInstance(topics[0], plugin.ModuleHelpTopic)
551
591
            self.assertEqual(demo_module, topics[0].module)
552
592
        finally:
553
 
            del sys.modules['bzrlib.plugins.demo_module']
 
593
            del sys.modules['breezy.plugins.demo_module']
554
594
 
555
595
 
556
596
class FakeModule(object):
594
634
    def test_get_help_text_with_additional_see_also(self):
595
635
        mod = FakeModule('two lines of help\nand more', 'demo')
596
636
        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']))
 
637
        self.assertEqual("two lines of help\nand more\n\n:See also: bar, foo\n",
 
638
                         topic.get_help_text(['foo', 'bar']))
599
639
 
600
640
    def test_get_help_topic(self):
601
641
        """The help topic for a plugin is its module name."""
602
 
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.demo')
 
642
        mod = FakeModule('two lines of help\nand more', 'breezy.plugins.demo')
603
643
        topic = plugin.ModuleHelpTopic(mod)
604
644
        self.assertEqual('demo', topic.get_help_topic())
605
 
        mod = FakeModule('two lines of help\nand more', 'bzrlib.plugins.foo_bar')
 
645
        mod = FakeModule('two lines of help\nand more',
 
646
                         'breezy.plugins.foo_bar')
606
647
        topic = plugin.ModuleHelpTopic(mod)
607
648
        self.assertEqual('foo_bar', topic.get_help_topic())
608
649
 
609
650
 
610
 
class TestLoadFromPath(tests.TestCaseInTempDir):
611
 
 
612
 
    def setUp(self):
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)
617
 
 
618
 
        # Monkey-patch load_from_path to stop it from actually loading anything.
619
 
        self.overrideAttr(plugin, 'load_from_path', lambda dirs: None)
620
 
 
621
 
    def test_set_plugins_path_with_args(self):
622
 
        plugin.set_plugins_path(['a', 'b'])
623
 
        self.assertEqual(['a', 'b'], bzrlib.plugins.__path__)
624
 
 
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__)
629
 
 
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'\\/$')
634
 
        try:
635
 
            from distutils.sysconfig import get_python_lib
636
 
        except ImportError:
637
 
            pass
638
 
        else:
639
 
            if sys.platform != 'win32':
640
 
                python_lib = get_python_lib()
641
 
                for directory in path:
642
 
                    if directory.startswith(python_lib):
643
 
                        break
644
 
                else:
645
 
                    self.fail('No path to global plugins')
646
 
 
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'\\/$')
652
 
 
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__, ['.'])
659
 
 
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__)
664
 
 
665
 
 
666
651
class TestEnvPluginPath(tests.TestCase):
667
652
 
668
 
    def setUp(self):
669
 
        super(TestEnvPluginPath, self).setUp()
670
 
        self.overrideAttr(plugin, 'DEFAULT_PLUGIN_PATH', None)
671
 
 
672
 
        self.user = plugin.get_user_plugin_path()
673
 
        self.site = plugin.get_site_plugin_path()
674
 
        self.core = plugin.get_core_plugin_path()
675
 
 
676
 
    def _list2paths(self, *args):
677
 
        paths = []
678
 
        for p in args:
679
 
            plugin._append_new_path(paths, p)
680
 
        return paths
681
 
 
682
 
    def _set_path(self, *args):
683
 
        path = os.pathsep.join(self._list2paths(*args))
684
 
        osutils.set_or_unset_env('BZR_PLUGIN_PATH', path)
 
653
    user = "USER"
 
654
    core = "CORE"
 
655
    site = "SITE"
685
656
 
686
657
    def check_path(self, expected_dirs, setting_dirs):
687
 
        if setting_dirs:
688
 
            self._set_path(*setting_dirs)
689
 
        actual = plugin.get_standard_plugins_path()
690
 
        self.assertEquals(self._list2paths(*expected_dirs), actual)
 
658
        if setting_dirs is None:
 
659
            del os.environ['BRZ_PLUGIN_PATH']
 
660
        else:
 
661
            os.environ['BRZ_PLUGIN_PATH'] = os.pathsep.join(setting_dirs)
 
662
        actual = [(p if t == 'path' else t.upper())
 
663
            for p, t in plugin._env_plugin_path()]
 
664
        self.assertEqual(expected_dirs, actual)
691
665
 
692
666
    def test_default(self):
693
667
        self.check_path([self.user, self.core, self.site],
757
731
                        ['+foo', '-bar'])
758
732
 
759
733
 
760
 
class TestDisablePlugin(tests.TestCaseInTempDir, TestPluginMixin):
761
 
 
762
 
    def setUp(self):
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')
 
734
class TestDisablePlugin(BaseTestPlugins):
769
735
 
770
736
    def test_cannot_import(self):
771
 
        osutils.set_or_unset_env('BZR_DISABLE_PLUGINS', 'test_foo')
772
 
        plugin.set_plugins_path(['.'])
 
737
        self.create_plugin_package('works')
 
738
        self.create_plugin_package('fails')
 
739
        self.overrideEnv('BRZ_DISABLE_PLUGINS', 'fails')
 
740
        self.update_module_paths(["."])
 
741
        import breezy.testingplugins.works as works
773
742
        try:
774
 
            import bzrlib.plugins.test_foo
 
743
            import breezy.testingplugins.fails as fails
775
744
        except ImportError:
776
745
            pass
777
 
        self.assertPluginUnknown('test_foo')
778
 
 
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)
785
 
 
786
 
    def test_not_loaded(self):
787
 
        self.warnings = []
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)
799
 
 
800
 
 
801
 
class TestLoadPluginAt(tests.TestCaseInTempDir, TestPluginMixin):
 
746
        else:
 
747
            self.fail("Loaded blocked plugin: " + repr(fails))
 
748
        self.assertPluginModules({'fails': None, 'works': works})
 
749
 
 
750
    def test_partial_imports(self):
 
751
        self.create_plugin('good')
 
752
        self.create_plugin('bad')
 
753
        self.create_plugin_package('ugly')
 
754
        self.overrideEnv('BRZ_DISABLE_PLUGINS', 'bad:ugly')
 
755
        self.load_with_paths(['.'])
 
756
        self.assertEqual({'good'}, viewkeys(self.plugins))
 
757
        self.assertPluginModules({
 
758
            'good': self.plugins['good'].module,
 
759
            'bad': None,
 
760
            'ugly': None,
 
761
        })
 
762
        # Ensure there are no warnings about plugins not being imported as
 
763
        # the user has explictly requested they be disabled.
 
764
        self.assertNotContainsRe(self.get_log(), r"Unable to load plugin")
 
765
 
 
766
 
 
767
class TestEnvDisablePlugins(tests.TestCase):
 
768
 
 
769
    def _get_names(self, env_value):
 
770
        os.environ['BRZ_DISABLE_PLUGINS'] = env_value
 
771
        return plugin._env_disable_plugins()
 
772
 
 
773
    def test_unset(self):
 
774
        self.assertEqual([], plugin._env_disable_plugins())
 
775
 
 
776
    def test_empty(self):
 
777
        self.assertEqual([], self._get_names(''))
 
778
 
 
779
    def test_single(self):
 
780
        self.assertEqual(['single'], self._get_names('single'))
 
781
 
 
782
    def test_multi(self):
 
783
        expected = ['one', 'two']
 
784
        self.assertEqual(expected, self._get_names(os.pathsep.join(expected)))
 
785
 
 
786
    def test_mixed(self):
 
787
        value = os.pathsep.join(['valid', 'in-valid'])
 
788
        self.assertEqual(['valid'], self._get_names(value))
 
789
        self.assertContainsRe(self.get_log(),
 
790
            r"Invalid name 'in-valid' in BRZ_DISABLE_PLUGINS=" + repr(value))
 
791
 
 
792
 
 
793
class TestEnvPluginsAt(tests.TestCase):
 
794
 
 
795
    def _get_paths(self, env_value):
 
796
        os.environ['BRZ_PLUGINS_AT'] = env_value
 
797
        return plugin._env_plugins_at()
 
798
 
 
799
    def test_empty(self):
 
800
        self.assertEqual([], plugin._env_plugins_at())
 
801
        self.assertEqual([], self._get_paths(''))
 
802
 
 
803
    def test_one_path(self):
 
804
        self.assertEqual([('b', 'man')], self._get_paths('b@man'))
 
805
 
 
806
    def test_multiple(self):
 
807
        self.assertEqual(
 
808
            [('tools', 'bzr-tools'), ('p', 'play.py')],
 
809
            self._get_paths(os.pathsep.join(('tools@bzr-tools', 'p@play.py'))))
 
810
 
 
811
    def test_many_at(self):
 
812
        self.assertEqual(
 
813
            [('church', 'StMichael@Plea@Norwich')],
 
814
            self._get_paths('church@StMichael@Plea@Norwich'))
 
815
 
 
816
    def test_only_py(self):
 
817
        self.assertEqual([('test', './test.py')], self._get_paths('./test.py'))
 
818
 
 
819
    def test_only_package(self):
 
820
        self.assertEqual([('py', '/opt/b/py')], self._get_paths('/opt/b/py'))
 
821
 
 
822
    def test_bad_name(self):
 
823
        self.assertEqual([], self._get_paths('/usr/local/bzr-git'))
 
824
        self.assertContainsRe(self.get_log(),
 
825
            r"Invalid name 'bzr-git' in BRZ_PLUGINS_AT='/usr/local/bzr-git'")
 
826
 
 
827
 
 
828
class TestLoadPluginAt(BaseTestPlugins):
802
829
 
803
830
    def setUp(self):
804
831
        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
832
        # Create the same plugin in two directories
812
833
        self.create_plugin_package('test_foo', dir='non-standard-dir')
813
834
        # The "normal" directory, we use 'standard' instead of 'plugins' to
817
838
    def assertTestFooLoadedFrom(self, path):
818
839
        self.assertPluginKnown('test_foo')
819
840
        self.assertDocstring('This is the doc for test_foo',
820
 
                             bzrlib.plugins.test_foo)
821
 
        self.assertEqual(path, bzrlib.plugins.test_foo.dir_source)
 
841
                             self.module.test_foo)
 
842
        self.assertEqual(path, self.module.test_foo.dir_source)
822
843
 
823
844
    def test_regular_load(self):
824
 
        plugin.load_plugins(['standard'])
 
845
        self.load_with_paths(['standard'])
825
846
        self.assertTestFooLoadedFrom('standard/test_foo')
826
847
 
827
848
    def test_import(self):
828
 
        osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
829
 
        plugin.set_plugins_path(['standard'])
830
 
        try:
831
 
            import bzrlib.plugins.test_foo
832
 
        except ImportError:
833
 
            pass
 
849
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
850
        self.update_module_paths(['standard'])
 
851
        import breezy.testingplugins.test_foo
834
852
        self.assertTestFooLoadedFrom('non-standard-dir')
835
853
 
836
854
    def test_loading(self):
837
 
        osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
838
 
        plugin.load_plugins(['standard'])
 
855
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
856
        self.load_with_paths(['standard'])
 
857
        self.assertTestFooLoadedFrom('non-standard-dir')
 
858
 
 
859
    def test_loading_other_name(self):
 
860
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
861
        os.rename('standard/test_foo', 'standard/test_bar')
 
862
        self.load_with_paths(['standard'])
839
863
        self.assertTestFooLoadedFrom('non-standard-dir')
840
864
 
841
865
    def test_compiled_loaded(self):
842
 
        osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
843
 
        plugin.load_plugins(['standard'])
 
866
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
867
        self.load_with_paths(['standard'])
844
868
        self.assertTestFooLoadedFrom('non-standard-dir')
845
 
        self.assertEqual('non-standard-dir/__init__.py',
846
 
                         bzrlib.plugins.test_foo.__file__)
 
869
        self.assertIsSameRealPath('non-standard-dir/__init__.py',
 
870
                                  self.module.test_foo.__file__)
847
871
 
848
872
        # 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'])
 
873
        os.remove('non-standard-dir/__init__.py')
 
874
        self.promote_cache('non-standard-dir')
 
875
        self.reset()
 
876
        self.load_with_paths(['standard'])
852
877
        self.assertTestFooLoadedFrom('non-standard-dir')
853
 
        if __debug__:
854
 
            suffix = 'pyc'
855
 
        else:
856
 
            suffix = 'pyo'
857
 
        self.assertEqual('non-standard-dir/__init__.%s' % suffix,
858
 
                         bzrlib.plugins.test_foo.__file__)
 
878
        suffix = plugin.COMPILED_EXT
 
879
        self.assertIsSameRealPath('non-standard-dir/__init__' + suffix,
 
880
                                  self.module.test_foo.__file__)
859
881
 
860
882
    def test_submodule_loading(self):
861
883
        # We create an additional directory under the one for test_foo
862
884
        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__)
 
885
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
886
        self.update_module_paths(['standard'])
 
887
        import breezy.testingplugins.test_foo
 
888
        self.assertEqual(self.module_prefix + 'test_foo',
 
889
                         self.module.test_foo.__package__)
 
890
        import breezy.testingplugins.test_foo.test_bar
 
891
        self.assertIsSameRealPath('non-standard-dir/test_bar/__init__.py',
 
892
                                  self.module.test_foo.test_bar.__file__)
 
893
 
 
894
    def test_relative_submodule_loading(self):
 
895
        self.create_plugin_package('test_foo', dir='another-dir', source='''
 
896
from . import test_bar
 
897
''')
 
898
        # We create an additional directory under the one for test_foo
 
899
        self.create_plugin_package('test_bar', dir='another-dir/test_bar')
 
900
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@another-dir')
 
901
        self.update_module_paths(['standard'])
 
902
        import breezy.testingplugins.test_foo
 
903
        self.assertEqual(self.module_prefix + 'test_foo',
 
904
                         self.module.test_foo.__package__)
 
905
        self.assertIsSameRealPath('another-dir/test_bar/__init__.py',
 
906
                                  self.module.test_foo.test_bar.__file__)
871
907
 
872
908
    def test_loading_from___init__only(self):
873
909
        # We rename the existing __init__.py file to ensure that we don't load
875
911
        init = 'non-standard-dir/__init__.py'
876
912
        random = 'non-standard-dir/setup.py'
877
913
        os.rename(init, random)
878
 
        self.addCleanup(os.rename, random, init)
879
 
        osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@non-standard-dir')
880
 
        plugin.load_plugins(['standard'])
 
914
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@non-standard-dir')
 
915
        self.load_with_paths(['standard'])
881
916
        self.assertPluginUnknown('test_foo')
882
917
 
883
918
    def test_loading_from_specific_file(self):
890
925
''' % ('test_foo', plugin_path)
891
926
        self.create_plugin('test_foo', source=source,
892
927
                           dir=plugin_dir, file_name=plugin_file_name)
893
 
        osutils.set_or_unset_env('BZR_PLUGINS_AT', 'test_foo@%s' % plugin_path)
894
 
        plugin.load_plugins(['standard'])
 
928
        self.overrideEnv('BRZ_PLUGINS_AT', 'test_foo@%s' % plugin_path)
 
929
        self.load_with_paths(['standard'])
895
930
        self.assertTestFooLoadedFrom(plugin_path)
 
931
 
 
932
 
 
933
class TestDescribePlugins(BaseTestPlugins):
 
934
 
 
935
    def test_describe_plugins(self):
 
936
        class DummyModule(object):
 
937
            __doc__ = 'Hi there'
 
938
        class DummyPlugin(object):
 
939
            __version__ = '0.1.0'
 
940
            module = DummyModule()
 
941
        self.plugin_warnings = {'bad': ['Failed to load (just testing)']}
 
942
        self.plugins = {'good': DummyPlugin()}
 
943
        self.assertEqual("""\
 
944
bad (failed to load)
 
945
  ** Failed to load (just testing)
 
946
 
 
947
good 0.1.0
 
948
  Hi there
 
949
 
 
950
""", ''.join(plugin.describe_plugins(state=self)))