← Back to branch summary

~bzr/ubuntu/lucid/bzr/beta-ppa

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_commands.py

  • Committer: Martin Pool
  • Date: 2010-08-18 04:26:39 UTC
  • mfrom: (129.1.8 packaging-karmic)
  • Revision ID: mbp@sourcefrog.net-20100818042639-mjoxtngyjwiu05fo
* PPA rebuild for lucid.
* PPA rebuild for karmic.
* PPA rebuild onto jaunty.
* New upstream release.

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 (
24
25
    config,
25
26
    errors,
26
27
    option,
 
28
    symbol_versioning,
27
29
    tests,
28
30
    )
29
31
from bzrlib.commands import display_command
32
34
 
33
35
class TestCommands(tests.TestCase):
34
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
 
35
48
    def test_display_command(self):
36
49
        """EPIPE message is selectively suppressed"""
37
50
        def pipe_thrower():
64
77
    @staticmethod
65
78
    def get_command(options):
66
79
        class cmd_foo(commands.Command):
67
 
            'Bar'
 
80
            __doc__ = 'Bar'
68
81
 
69
82
            takes_options = options
70
83
 
111
124
 
112
125
    def test_unicode(self):
113
126
        my_config = self._get_config("[ALIASES]\n"
114
 
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
 
127
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
115
128
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
116
129
                          commands.get_alias("iam", config=my_config))
117
130
 
119
132
class TestSeeAlso(tests.TestCase):
120
133
    """Tests for the see also functional of Command."""
121
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
 
122
142
    def test_default_subclass_no_see_also(self):
123
 
        class ACommand(commands.Command):
124
 
            """A sample command."""
125
 
        command = ACommand()
 
143
        command = self._get_command_with_see_also([])
126
144
        self.assertEqual([], command.get_see_also())
127
145
 
128
146
    def test__see_also(self):
129
147
        """When _see_also is defined, it sets the result of get_see_also()."""
130
 
        class ACommand(commands.Command):
131
 
            _see_also = ['bar', 'foo']
132
 
        command = ACommand()
 
148
        command = self._get_command_with_see_also(['bar', 'foo'])
133
149
        self.assertEqual(['bar', 'foo'], command.get_see_also())
134
150
 
135
151
    def test_deduplication(self):
136
152
        """Duplicates in _see_also are stripped out."""
137
 
        class ACommand(commands.Command):
138
 
            _see_also = ['foo', 'foo']
139
 
        command = ACommand()
 
153
        command = self._get_command_with_see_also(['foo', 'foo'])
140
154
        self.assertEqual(['foo'], command.get_see_also())
141
155
 
142
156
    def test_sorted(self):
143
157
        """_see_also is sorted by get_see_also."""
144
 
        class ACommand(commands.Command):
145
 
            _see_also = ['foo', 'bar']
146
 
        command = ACommand()
 
158
        command = self._get_command_with_see_also(['foo', 'bar'])
147
159
        self.assertEqual(['bar', 'foo'], command.get_see_also())
148
160
 
149
161
    def test_additional_terms(self):
150
162
        """Additional terms can be supplied and are deduped and sorted."""
151
 
        class ACommand(commands.Command):
152
 
            _see_also = ['foo', 'bar']
153
 
        command = ACommand()
 
163
        command = self._get_command_with_see_also(['foo', 'bar'])
154
164
        self.assertEqual(['bar', 'foo', 'gam'],
155
165
            command.get_see_also(['gam', 'bar', 'gam']))
156
166
 
210
220
        commands.Command.hooks.install_named_hook(
211
221
            "extend_command", hook_calls.append, None)
212
222
        # create a command, should not fire
213
 
        class ACommand(commands.Command):
214
 
            """A sample command."""
215
 
        cmd = ACommand()
 
223
        class cmd_test_extend_command_hook(commands.Command):
 
224
            __doc__ = """A sample command."""
216
225
        self.assertEqual([], hook_calls)
217
226
        # -- as a builtin
218
227
        # register the command class, should not fire
219
228
        try:
220
 
            builtins.cmd_test_extend_command_hook = ACommand
 
229
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
221
230
            self.assertEqual([], hook_calls)
222
231
            # and ask for the object, should fire
223
232
            cmd = commands.get_cmd_object('test-extend-command-hook')
227
236
            self.assertSubset([cmd], hook_calls)
228
237
            del hook_calls[:]
229
238
        finally:
230
 
            del builtins.cmd_test_extend_command_hook
 
239
            commands.builtin_command_registry.remove('test-extend-command-hook')
231
240
        # -- as a plugin lazy registration
232
241
        try:
233
242
            # register the command class, should not fire
249
258
        commands.install_bzr_command_hooks()
250
259
        hook_calls = []
251
260
        class ACommand(commands.Command):
252
 
            """A sample command."""
 
261
            __doc__ = """A sample command."""
253
262
        def get_cmd(cmd_or_None, cmd_name):
254
263
            hook_calls.append(('called', cmd_or_None, cmd_name))
255
264
            if cmd_name in ('foo', 'info'):
276
285
 
277
286
class TestGetMissingCommandHook(tests.TestCase):
278
287
 
279
 
    def test_fires_on_get_cmd_object(self):
280
 
        # The get_missing_command(cmd) hook fires when commands are delivered to the
281
 
        # ui.
282
 
        hook_calls = []
 
288
    def hook_missing(self):
 
289
        """Hook get_missing_command for testing."""
 
290
        self.hook_calls = []
283
291
        class ACommand(commands.Command):
284
 
            """A sample command."""
 
292
            __doc__ = """A sample command."""
285
293
        def get_missing_cmd(cmd_name):
286
 
            hook_calls.append(('called', cmd_name))
 
294
            self.hook_calls.append(('called', cmd_name))
287
295
            if cmd_name in ('foo', 'info'):
288
296
                return ACommand()
289
297
        commands.Command.hooks.install_named_hook(
290
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()
291
305
        # create a command directly, should not fire
292
 
        cmd = ACommand()
293
 
        self.assertEqual([], hook_calls)
 
306
        self.cmd = self.ACommand()
 
307
        self.assertEqual([], self.hook_calls)
294
308
        # ask by name, should fire and give us our command
295
309
        cmd = commands.get_cmd_object('foo')
296
 
        self.assertEqual([('called', 'foo')], hook_calls)
297
 
        self.assertIsInstance(cmd, ACommand)
298
 
        del hook_calls[:]
 
310
        self.assertEqual([('called', 'foo')], self.hook_calls)
 
311
        self.assertIsInstance(cmd, self.ACommand)
 
312
        del self.hook_calls[:]
299
313
        # ask by a name that is supplied by a builtin - the hook should not
300
314
        # fire and we still get our object.
301
315
        commands.install_bzr_command_hooks()
302
316
        cmd = commands.get_cmd_object('info')
303
317
        self.assertNotEqual(None, cmd)
304
 
        self.assertEqual(0, len(hook_calls))
 
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)
305
327
 
306
328
 
307
329
class TestListCommandHook(tests.TestCase):
323
345
        cmds = list(commands.all_command_names())
324
346
        self.assertEqual(['called'], hook_calls)
325
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')