/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 bzrlib/tests/test_plugins.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

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