← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_commands.py

  • Committer: Martin Pool
  • Date: 2010-07-16 15:35:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5351.
  • Revision ID: mbp@canonical.com-20100716153543-2sm0z5ajidcc2ytw
Use open_containing_paths

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_commands.py
1
 
# Copyright (C) 2004, 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
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
from cStringIO import StringIO
18
18
import errno
 
19
import inspect
19
20
import sys
20
21
 
21
22
from bzrlib import (
23
24
    commands,
24
25
    config,
25
26
    errors,
 
27
    option,
 
28
    symbol_versioning,
26
29
    tests,
27
30
    )
28
31
from bzrlib.commands import display_command
31
34
 
32
35
class TestCommands(tests.TestCase):
33
36
 
 
37
    def test_all_commands_have_help(self):
 
38
        commands._register_builtin_commands()
 
39
        commands_without_help = set()
 
40
        base_doc = inspect.getdoc(commands.Command)
 
41
        for cmd_name in commands.all_command_names():
 
42
            cmd = commands.get_cmd_object(cmd_name)
 
43
            cmd_help = cmd.help()
 
44
            if not cmd_help or cmd_help == base_doc:
 
45
                commands_without_help.append(cmd_name)
 
46
        self.assertLength(0, commands_without_help)
 
47
 
34
48
    def test_display_command(self):
35
49
        """EPIPE message is selectively suppressed"""
36
50
        def pipe_thrower():
60
74
        self.assertRaises(errors.BzrCommandError,
61
75
                          commands.run_bzr, ['log', u'--option\xb5'])
62
76
 
 
77
    @staticmethod
 
78
    def get_command(options):
 
79
        class cmd_foo(commands.Command):
 
80
            __doc__ = 'Bar'
 
81
 
 
82
            takes_options = options
 
83
 
 
84
        return cmd_foo()
 
85
 
 
86
    def test_help_hidden(self):
 
87
        c = self.get_command([option.Option('foo', hidden=True)])
 
88
        self.assertNotContainsRe(c.get_help_text(), '--foo')
 
89
 
 
90
    def test_help_not_hidden(self):
 
91
        c = self.get_command([option.Option('foo', hidden=False)])
 
92
        self.assertContainsRe(c.get_help_text(), '--foo')
 
93
 
63
94
 
64
95
class TestGetAlias(tests.TestCase):
65
96
 
93
124
 
94
125
    def test_unicode(self):
95
126
        my_config = self._get_config("[ALIASES]\n"
96
 
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
 
127
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
97
128
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
98
129
                          commands.get_alias("iam", config=my_config))
99
130
 
101
132
class TestSeeAlso(tests.TestCase):
102
133
    """Tests for the see also functional of Command."""
103
134
 
 
135
    @staticmethod
 
136
    def _get_command_with_see_also(see_also):
 
137
        class ACommand(commands.Command):
 
138
            __doc__ = """A sample command."""
 
139
            _see_also = see_also
 
140
        return ACommand()
 
141
 
104
142
    def test_default_subclass_no_see_also(self):
105
 
        class ACommand(commands.Command):
106
 
            """A sample command."""
107
 
        command = ACommand()
 
143
        command = self._get_command_with_see_also([])
108
144
        self.assertEqual([], command.get_see_also())
109
145
 
110
146
    def test__see_also(self):
111
147
        """When _see_also is defined, it sets the result of get_see_also()."""
112
 
        class ACommand(commands.Command):
113
 
            _see_also = ['bar', 'foo']
114
 
        command = ACommand()
 
148
        command = self._get_command_with_see_also(['bar', 'foo'])
115
149
        self.assertEqual(['bar', 'foo'], command.get_see_also())
116
150
 
117
151
    def test_deduplication(self):
118
152
        """Duplicates in _see_also are stripped out."""
119
 
        class ACommand(commands.Command):
120
 
            _see_also = ['foo', 'foo']
121
 
        command = ACommand()
 
153
        command = self._get_command_with_see_also(['foo', 'foo'])
122
154
        self.assertEqual(['foo'], command.get_see_also())
123
155
 
124
156
    def test_sorted(self):
125
157
        """_see_also is sorted by get_see_also."""
126
 
        class ACommand(commands.Command):
127
 
            _see_also = ['foo', 'bar']
128
 
        command = ACommand()
 
158
        command = self._get_command_with_see_also(['foo', 'bar'])
129
159
        self.assertEqual(['bar', 'foo'], command.get_see_also())
130
160
 
131
161
    def test_additional_terms(self):
132
162
        """Additional terms can be supplied and are deduped and sorted."""
133
 
        class ACommand(commands.Command):
134
 
            _see_also = ['foo', 'bar']
135
 
        command = ACommand()
 
163
        command = self._get_command_with_see_also(['foo', 'bar'])
136
164
        self.assertEqual(['bar', 'foo', 'gam'],
137
165
            command.get_see_also(['gam', 'bar', 'gam']))
138
166
 
145
173
        del sys.modules['bzrlib.tests.fake_command']
146
174
        global lazy_command_imported
147
175
        lazy_command_imported = False
 
176
        commands.install_bzr_command_hooks()
148
177
 
149
178
    @staticmethod
150
179
    def remove_fake():
187
216
        # commands are registered).
188
217
        # when they are simply created.
189
218
        hook_calls = []
 
219
        commands.install_bzr_command_hooks()
190
220
        commands.Command.hooks.install_named_hook(
191
221
            "extend_command", hook_calls.append, None)
192
222
        # create a command, should not fire
193
 
        class ACommand(commands.Command):
194
 
            """A sample command."""
195
 
        cmd = ACommand()
 
223
        class cmd_test_extend_command_hook(commands.Command):
 
224
            __doc__ = """A sample command."""
196
225
        self.assertEqual([], hook_calls)
197
226
        # -- as a builtin
198
227
        # register the command class, should not fire
199
228
        try:
200
 
            builtins.cmd_test_extend_command_hook = ACommand
 
229
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
201
230
            self.assertEqual([], hook_calls)
202
231
            # and ask for the object, should fire
203
232
            cmd = commands.get_cmd_object('test-extend-command-hook')
207
236
            self.assertSubset([cmd], hook_calls)
208
237
            del hook_calls[:]
209
238
        finally:
210
 
            del builtins.cmd_test_extend_command_hook
 
239
            commands.builtin_command_registry.remove('test-extend-command-hook')
211
240
        # -- as a plugin lazy registration
212
241
        try:
213
242
            # register the command class, should not fire
219
248
            self.assertEqual([cmd], hook_calls)
220
249
        finally:
221
250
            commands.plugin_cmds.remove('fake')
 
251
 
 
252
 
 
253
class TestGetCommandHook(tests.TestCase):
 
254
 
 
255
    def test_fires_on_get_cmd_object(self):
 
256
        # The get_command(cmd) hook fires when commands are delivered to the
 
257
        # ui.
 
258
        commands.install_bzr_command_hooks()
 
259
        hook_calls = []
 
260
        class ACommand(commands.Command):
 
261
            __doc__ = """A sample command."""
 
262
        def get_cmd(cmd_or_None, cmd_name):
 
263
            hook_calls.append(('called', cmd_or_None, cmd_name))
 
264
            if cmd_name in ('foo', 'info'):
 
265
                return ACommand()
 
266
        commands.Command.hooks.install_named_hook(
 
267
            "get_command", get_cmd, None)
 
268
        # create a command directly, should not fire
 
269
        cmd = ACommand()
 
270
        self.assertEqual([], hook_calls)
 
271
        # ask by name, should fire and give us our command
 
272
        cmd = commands.get_cmd_object('foo')
 
273
        self.assertEqual([('called', None, 'foo')], hook_calls)
 
274
        self.assertIsInstance(cmd, ACommand)
 
275
        del hook_calls[:]
 
276
        # ask by a name that is supplied by a builtin - the hook should still
 
277
        # fire and we still get our object, but we should see the builtin
 
278
        # passed to the hook.
 
279
        cmd = commands.get_cmd_object('info')
 
280
        self.assertIsInstance(cmd, ACommand)
 
281
        self.assertEqual(1, len(hook_calls))
 
282
        self.assertEqual('info', hook_calls[0][2])
 
283
        self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
 
284
 
 
285
 
 
286
class TestGetMissingCommandHook(tests.TestCase):
 
287
 
 
288
    def hook_missing(self):
 
289
        """Hook get_missing_command for testing."""
 
290
        self.hook_calls = []
 
291
        class ACommand(commands.Command):
 
292
            __doc__ = """A sample command."""
 
293
        def get_missing_cmd(cmd_name):
 
294
            self.hook_calls.append(('called', cmd_name))
 
295
            if cmd_name in ('foo', 'info'):
 
296
                return ACommand()
 
297
        commands.Command.hooks.install_named_hook(
 
298
            "get_missing_command", get_missing_cmd, None)
 
299
        self.ACommand = ACommand
 
300
 
 
301
    def test_fires_on_get_cmd_object(self):
 
302
        # The get_missing_command(cmd) hook fires when commands are delivered to the
 
303
        # ui.
 
304
        self.hook_missing()
 
305
        # create a command directly, should not fire
 
306
        self.cmd = self.ACommand()
 
307
        self.assertEqual([], self.hook_calls)
 
308
        # ask by name, should fire and give us our command
 
309
        cmd = commands.get_cmd_object('foo')
 
310
        self.assertEqual([('called', 'foo')], self.hook_calls)
 
311
        self.assertIsInstance(cmd, self.ACommand)
 
312
        del self.hook_calls[:]
 
313
        # ask by a name that is supplied by a builtin - the hook should not
 
314
        # fire and we still get our object.
 
315
        commands.install_bzr_command_hooks()
 
316
        cmd = commands.get_cmd_object('info')
 
317
        self.assertNotEqual(None, cmd)
 
318
        self.assertEqual(0, len(self.hook_calls))
 
319
 
 
320
    def test_skipped_on_HelpCommandIndex_get_topics(self):
 
321
        # The get_missing_command(cmd_name) hook is not fired when
 
322
        # looking up help topics.
 
323
        self.hook_missing()
 
324
        topic = commands.HelpCommandIndex()
 
325
        topics = topic.get_topics('foo')
 
326
        self.assertEqual([], self.hook_calls)
 
327
 
 
328
 
 
329
class TestListCommandHook(tests.TestCase):
 
330
 
 
331
    def test_fires_on_all_command_names(self):
 
332
        # The list_commands() hook fires when all_command_names() is invoked.
 
333
        hook_calls = []
 
334
        commands.install_bzr_command_hooks()
 
335
        def list_my_commands(cmd_names):
 
336
            hook_calls.append('called')
 
337
            cmd_names.update(['foo', 'bar'])
 
338
            return cmd_names
 
339
        commands.Command.hooks.install_named_hook(
 
340
            "list_commands", list_my_commands, None)
 
341
        # Get a command, which should not trigger the hook.
 
342
        cmd = commands.get_cmd_object('info')
 
343
        self.assertEqual([], hook_calls)
 
344
        # Get all command classes (for docs and shell completion).
 
345
        cmds = list(commands.all_command_names())
 
346
        self.assertEqual(['called'], hook_calls)
 
347
        self.assertSubset(['foo', 'bar'], cmds)
 
348
 
 
349
class TestDeprecations(tests.TestCase):
 
350
 
 
351
    def test_shlex_split_unicode_deprecation(self):
 
352
        res = self.applyDeprecated(
 
353
                symbol_versioning.deprecated_in((2, 2, 0)),
 
354
                commands.shlex_split_unicode, 'whatever')