← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_plugins.py

Slight plugin tests rewriting.

* bzrlib/tests/test_plugins.py:
(TestPluginMixin): Factor out common operations.
(TestLoadingPlugins, TestPlugins): Simplify accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_plugins.py
29
29
from bzrlib import (
30
30
    osutils,
31
31
    plugin,
 
32
    plugins,
32
33
    tests,
33
34
    )
34
35
 
35
36
 
36
37
# TODO: Write a test for plugin decoration of commands.
37
38
 
38
 
class TestLoadingPlugins(tests.TestCaseInTempDir):
 
39
class TestPluginMixin(object):
 
40
 
 
41
    def _unregister_plugin(self, name):
 
42
        """Remove the plugin from sys.modules and the bzrlib namespace."""
 
43
        py_name = 'bzrlib.plugins.%s' % name
 
44
        if py_name in sys.modules:
 
45
            del sys.modules[py_name]
 
46
        if getattr(bzrlib.plugins, name, None) is not None:
 
47
            delattr(bzrlib.plugins, name)
 
48
 
 
49
    def assertPluginUnknown(self, name):
 
50
        self.failIf(getattr(bzrlib.plugins, 'plugin', None) is not None)
 
51
        self.failIf('bzrlib.plugins.%s' % name in sys.modules)
 
52
 
 
53
    def assertPluginKnown(self, name):
 
54
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None) is not None)
 
55
        self.failUnless('bzrlib.plugins.%s' % name in sys.modules)
 
56
 
 
57
 
 
58
class TestLoadingPlugins(tests.TestCaseInTempDir, TestPluginMixin):
39
59
 
40
60
    activeattributes = {}
41
61
 
49
69
        # set a place for the plugins to record their loading, and at the same
50
70
        # time validate that the location the plugins should record to is
51
71
        # valid and correct.
52
 
        bzrlib.tests.test_plugins.TestLoadingPlugins.activeattributes \
53
 
            [tempattribute] = []
 
72
        self.__class__.activeattributes [tempattribute] = []
54
73
        self.failUnless(tempattribute in self.activeattributes)
55
74
        # create two plugin directories
56
75
        os.mkdir('first')
80
99
        finally:
81
100
            # remove the plugin 'plugin'
82
101
            del self.activeattributes[tempattribute]
83
 
            if 'bzrlib.plugins.plugin' in sys.modules:
84
 
                del sys.modules['bzrlib.plugins.plugin']
85
 
            if getattr(bzrlib.plugins, 'plugin', None):
86
 
                del bzrlib.plugins.plugin
87
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
102
            self._unregister_plugin('plugin')
 
103
        self.assertPluginUnknown('plugin')
88
104
 
89
105
    def test_plugins_from_different_dirs_can_demand_load(self):
 
106
        self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
107
        self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
90
108
        # This test tests that having two plugins in different
91
109
        # directories with different names allows them both to be loaded, when
92
110
        # we do a direct import statement.
124
142
 
125
143
        oldpath = bzrlib.plugins.__path__
126
144
        try:
 
145
            self.failIf('bzrlib.plugins.pluginone' in sys.modules)
 
146
            self.failIf('bzrlib.plugins.plugintwo' in sys.modules)
127
147
            bzrlib.plugins.__path__ = ['first', 'second']
128
148
            exec "import bzrlib.plugins.pluginone"
129
149
            self.assertEqual(['first'], self.activeattributes[tempattribute])
133
153
        finally:
134
154
            # remove the plugin 'plugin'
135
155
            del self.activeattributes[tempattribute]
136
 
            if getattr(bzrlib.plugins, 'pluginone', None):
137
 
                del bzrlib.plugins.pluginone
138
 
            if getattr(bzrlib.plugins, 'plugintwo', None):
139
 
                del bzrlib.plugins.plugintwo
140
 
        self.failIf(getattr(bzrlib.plugins, 'pluginone', None))
141
 
        self.failIf(getattr(bzrlib.plugins, 'plugintwo', None))
 
156
            self._unregister_plugin('pluginone')
 
157
            self._unregister_plugin('plugintwo')
 
158
        self.assertPluginUnknown('pluginone')
 
159
        self.assertPluginUnknown('plugintwo')
142
160
 
143
161
    def test_plugins_can_load_from_directory_with_trailing_slash(self):
144
162
        # This test tests that a plugin can load from a directory when the
145
163
        # directory in the path has a trailing slash.
146
164
        # check the plugin is not loaded already
147
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
165
        self.assertPluginUnknown('ts_plugin')
148
166
        tempattribute = "trailing-slash"
149
167
        self.failIf(tempattribute in self.activeattributes)
150
168
        # set a place for the plugin to record its loading, and at the same
171
189
            bzrlib.plugin.load_from_path(['plugin_test'+os.sep])
172
190
            self.assertEqual(['plugin'], self.activeattributes[tempattribute])
173
191
        finally:
174
 
            # remove the plugin 'plugin'
175
192
            del self.activeattributes[tempattribute]
176
 
            if getattr(bzrlib.plugins, 'ts_plugin', None):
177
 
                del bzrlib.plugins.ts_plugin
178
 
        self.failIf(getattr(bzrlib.plugins, 'ts_plugin', None))
 
193
            self._unregister_plugin('ts_plugin')
 
194
        self.assertPluginUnknown('ts_plugin')
179
195
 
180
196
    def load_and_capture(self, name):
181
197
        """Load plugins from '.' capturing the output.
232
248
            "it to 'bad_plugin_name_'\.")
233
249
 
234
250
 
235
 
class TestPlugins(tests.TestCaseInTempDir):
 
251
class TestPlugins(tests.TestCaseInTempDir, TestPluginMixin):
236
252
 
237
253
    def setup_plugin(self, source=""):
238
254
        # This test tests a new plugin appears in bzrlib.plugin.plugins().
239
255
        # check the plugin is not loaded already
240
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
256
        self.assertPluginUnknown('plugin')
241
257
        # write a plugin that _cannot_ fail to load.
242
258
        file('plugin.py', 'w').write(source + '\n')
243
259
        self.addCleanup(self.teardown_plugin)
244
 
        bzrlib.plugin.load_from_path(['.'])
 
260
        plugin.load_from_path(['.'])
245
261
 
246
262
    def teardown_plugin(self):
247
 
        # remove the plugin 'plugin'
248
 
        if 'bzrlib.plugins.plugin' in sys.modules:
249
 
            del sys.modules['bzrlib.plugins.plugin']
250
 
        if getattr(bzrlib.plugins, 'plugin', None):
251
 
            del bzrlib.plugins.plugin
252
 
        self.failIf(getattr(bzrlib.plugins, 'plugin', None))
 
263
        self._unregister_plugin('plugin')
 
264
        self.assertPluginUnknown('plugin')
253
265
 
254
266
    def test_plugin_appears_in_plugins(self):
255
267
        self.setup_plugin()
256
 
        self.failUnless('plugin' in bzrlib.plugin.plugins())
257
 
        self.failUnless(getattr(bzrlib.plugins, 'plugin', None))
258
 
        plugins = bzrlib.plugin.plugins()
259
 
        plugin = plugins['plugin']
260
 
        self.assertIsInstance(plugin, bzrlib.plugin.PlugIn)
261
 
        self.assertEqual(bzrlib.plugins.plugin, plugin.module)
 
268
        self.assertPluginKnown('plugin')
 
269
        p = plugin.plugins()['plugin']
 
270
        self.assertIsInstance(p, bzrlib.plugin.PlugIn)
 
271
        self.assertEqual(p.module, plugins.plugin)
262
272
 
263
273
    def test_trivial_plugin_get_path(self):
264
274
        self.setup_plugin()
265
 
        plugins = bzrlib.plugin.plugins()
266
 
        plugin = plugins['plugin']
 
275
        p = plugin.plugins()['plugin']
267
276
        plugin_path = self.test_dir + '/plugin.py'
268
 
        self.assertIsSameRealPath(plugin_path, osutils.normpath(plugin.path()))
 
277
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
269
278
 
270
279
    def test_plugin_get_path_py_not_pyc(self):
271
280
        # first import creates plugin.pyc
272
281
        self.setup_plugin()
273
282
        self.teardown_plugin()
274
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc
275
 
        plugins = bzrlib.plugin.plugins()
276
 
        plugin = plugins['plugin']
 
283
        plugin.load_from_path(['.']) # import plugin.pyc
 
284
        p = plugin.plugins()['plugin']
277
285
        plugin_path = self.test_dir + '/plugin.py'
278
 
        self.assertIsSameRealPath(plugin_path, osutils.normpath(plugin.path()))
 
286
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
279
287
 
280
288
    def test_plugin_get_path_pyc_only(self):
281
289
        # first import creates plugin.pyc (or plugin.pyo depending on __debug__)
282
290
        self.setup_plugin()
283
291
        self.teardown_plugin()
284
292
        os.unlink(self.test_dir + '/plugin.py')
285
 
        bzrlib.plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
286
 
        plugins = bzrlib.plugin.plugins()
287
 
        plugin = plugins['plugin']
 
293
        plugin.load_from_path(['.']) # import plugin.pyc (or .pyo)
 
294
        p = plugin.plugins()['plugin']
288
295
        if __debug__:
289
296
            plugin_path = self.test_dir + '/plugin.pyc'
290
297
        else:
291
298
            plugin_path = self.test_dir + '/plugin.pyo'
292
 
        self.assertIsSameRealPath(plugin_path, osutils.normpath(plugin.path()))
 
299
        self.assertIsSameRealPath(plugin_path, osutils.normpath(p.path()))
293
300
 
294
301
    def test_no_test_suite_gives_None_for_test_suite(self):
295
302
        self.setup_plugin()
296
 
        plugin = bzrlib.plugin.plugins()['plugin']
297
 
        self.assertEqual(None, plugin.test_suite())
 
303
        p = plugin.plugins()['plugin']
 
304
        self.assertEqual(None, p.test_suite())
298
305
 
299
306
    def test_test_suite_gives_test_suite_result(self):
300
307
        source = """def test_suite(): return 'foo'"""
301
308
        self.setup_plugin(source)
302
 
        plugin = bzrlib.plugin.plugins()['plugin']
303
 
        self.assertEqual('foo', plugin.test_suite())
 
309
        p = plugin.plugins()['plugin']
 
310
        self.assertEqual('foo', p.test_suite())
304
311
 
305
312
    def test_no_load_plugin_tests_gives_None_for_load_plugin_tests(self):
306
313
        self.setup_plugin()
307
314
        loader = tests.TestUtil.TestLoader()
308
 
        plugin = bzrlib.plugin.plugins()['plugin']
309
 
        self.assertEqual(None, plugin.load_plugin_tests(loader))
 
315
        p = plugin.plugins()['plugin']
 
316
        self.assertEqual(None, p.load_plugin_tests(loader))
310
317
 
311
318
    def test_load_plugin_tests_gives_load_plugin_tests_result(self):
312
319
        source = """
314
321
    return 'foo'"""
315
322
        self.setup_plugin(source)
316
323
        loader = tests.TestUtil.TestLoader()
317
 
        plugin = bzrlib.plugin.plugins()['plugin']
318
 
        self.assertEqual('foo', plugin.load_plugin_tests(loader))
 
324
        p = plugin.plugins()['plugin']
 
325
        self.assertEqual('foo', p.load_plugin_tests(loader))
 
326
 
 
327
    def check_version_info(self, expected, source='', name='plugin'):
 
328
        self.setup_plugin(source)
 
329
        self.assertEqual(expected, plugin.plugins()[name].version_info())
319
330
 
320
331
    def test_no_version_info(self):
321
 
        self.setup_plugin()
322
 
        plugin = bzrlib.plugin.plugins()['plugin']
323
 
        self.assertEqual(None, plugin.version_info())
 
332
        self.check_version_info(None)
324
333
 
325
334
    def test_with_version_info(self):
326
 
        self.setup_plugin("version_info = (1, 2, 3, 'dev', 4)")
327
 
        plugin = bzrlib.plugin.plugins()['plugin']
328
 
        self.assertEqual((1, 2, 3, 'dev', 4), plugin.version_info())
 
335
        self.check_version_info((1, 2, 3, 'dev', 4),
 
336
                                "version_info = (1, 2, 3, 'dev', 4)")
329
337
 
330
338
    def test_short_version_info_gets_padded(self):
331
339
        # the gtk plugin has version_info = (1,2,3) rather than the 5-tuple.
332
340
        # so we adapt it
333
 
        self.setup_plugin("version_info = (1, 2, 3)")
334
 
        plugin = bzrlib.plugin.plugins()['plugin']
335
 
        self.assertEqual((1, 2, 3, 'final', 0), plugin.version_info())
 
341
        self.check_version_info((1, 2, 3, 'final', 0),
 
342
                                "version_info = (1, 2, 3)")
 
343
 
 
344
    def check_version(self, expected, source=None, name='plugin'):
 
345
        self.setup_plugin(source)
 
346
        self.assertEqual(expected, plugins[name].__version__)
336
347
 
337
348
    def test_no_version_info___version__(self):
338
349
        self.setup_plugin()
711
722
    def test_bogus_references(self):
712
723
        self.check_path(['+foo', '-bar', self.core, self.site],
713
724
                        ['+foo', '-bar'])
 
725