← 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: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 03:19:13 UTC
  • mfrom: (4792.9.3 profile-imports)
  • Revision ID: pqm@pqm.ubuntu.com-20100211031913-hu2gowhvmu10djr8
(mbp) profile_imports handles single-argument __import__

Show diffs side-by-side

added added

removed removed

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