← 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-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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
 
82
95
class TestGetAlias(tests.TestCase):
83
96
 
84
97
    def _get_config(self, config_text):
85
 
        my_config = config.GlobalConfig()
86
 
        config_file = StringIO(config_text.encode('utf-8'))
87
 
        my_config._parser = my_config._get_parser(file=config_file)
 
98
        my_config = config.GlobalConfig.from_string(config_text)
88
99
        return my_config
89
100
 
90
101
    def test_simple(self):
111
122
 
112
123
    def test_unicode(self):
113
124
        my_config = self._get_config("[ALIASES]\n"
114
 
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
 
125
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
115
126
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
116
127
                          commands.get_alias("iam", config=my_config))
117
128
 
119
130
class TestSeeAlso(tests.TestCase):
120
131
    """Tests for the see also functional of Command."""
121
132
 
 
133
    @staticmethod
 
134
    def _get_command_with_see_also(see_also):
 
135
        class ACommand(commands.Command):
 
136
            __doc__ = """A sample command."""
 
137
            _see_also = see_also
 
138
        return ACommand()
 
139
 
122
140
    def test_default_subclass_no_see_also(self):
123
 
        class ACommand(commands.Command):
124
 
            """A sample command."""
125
 
        command = ACommand()
 
141
        command = self._get_command_with_see_also([])
126
142
        self.assertEqual([], command.get_see_also())
127
143
 
128
144
    def test__see_also(self):
129
145
        """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()
 
146
        command = self._get_command_with_see_also(['bar', 'foo'])
133
147
        self.assertEqual(['bar', 'foo'], command.get_see_also())
134
148
 
135
149
    def test_deduplication(self):
136
150
        """Duplicates in _see_also are stripped out."""
137
 
        class ACommand(commands.Command):
138
 
            _see_also = ['foo', 'foo']
139
 
        command = ACommand()
 
151
        command = self._get_command_with_see_also(['foo', 'foo'])
140
152
        self.assertEqual(['foo'], command.get_see_also())
141
153
 
142
154
    def test_sorted(self):
143
155
        """_see_also is sorted by get_see_also."""
144
 
        class ACommand(commands.Command):
145
 
            _see_also = ['foo', 'bar']
146
 
        command = ACommand()
 
156
        command = self._get_command_with_see_also(['foo', 'bar'])
147
157
        self.assertEqual(['bar', 'foo'], command.get_see_also())
148
158
 
149
159
    def test_additional_terms(self):
150
160
        """Additional terms can be supplied and are deduped and sorted."""
151
 
        class ACommand(commands.Command):
152
 
            _see_also = ['foo', 'bar']
153
 
        command = ACommand()
 
161
        command = self._get_command_with_see_also(['foo', 'bar'])
154
162
        self.assertEqual(['bar', 'foo', 'gam'],
155
163
            command.get_see_also(['gam', 'bar', 'gam']))
156
164
 
210
218
        commands.Command.hooks.install_named_hook(
211
219
            "extend_command", hook_calls.append, None)
212
220
        # create a command, should not fire
213
 
        class ACommand(commands.Command):
214
 
            """A sample command."""
215
 
        cmd = ACommand()
 
221
        class cmd_test_extend_command_hook(commands.Command):
 
222
            __doc__ = """A sample command."""
216
223
        self.assertEqual([], hook_calls)
217
224
        # -- as a builtin
218
225
        # register the command class, should not fire
219
226
        try:
220
 
            builtins.cmd_test_extend_command_hook = ACommand
 
227
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
221
228
            self.assertEqual([], hook_calls)
222
229
            # and ask for the object, should fire
223
230
            cmd = commands.get_cmd_object('test-extend-command-hook')
227
234
            self.assertSubset([cmd], hook_calls)
228
235
            del hook_calls[:]
229
236
        finally:
230
 
            del builtins.cmd_test_extend_command_hook
 
237
            commands.builtin_command_registry.remove('test-extend-command-hook')
231
238
        # -- as a plugin lazy registration
232
239
        try:
233
240
            # register the command class, should not fire
249
256
        commands.install_bzr_command_hooks()
250
257
        hook_calls = []
251
258
        class ACommand(commands.Command):
252
 
            """A sample command."""
 
259
            __doc__ = """A sample command."""
253
260
        def get_cmd(cmd_or_None, cmd_name):
254
261
            hook_calls.append(('called', cmd_or_None, cmd_name))
255
262
            if cmd_name in ('foo', 'info'):
276
283
 
277
284
class TestGetMissingCommandHook(tests.TestCase):
278
285
 
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 = []
 
286
    def hook_missing(self):
 
287
        """Hook get_missing_command for testing."""
 
288
        self.hook_calls = []
283
289
        class ACommand(commands.Command):
284
 
            """A sample command."""
 
290
            __doc__ = """A sample command."""
285
291
        def get_missing_cmd(cmd_name):
286
 
            hook_calls.append(('called', cmd_name))
 
292
            self.hook_calls.append(('called', cmd_name))
287
293
            if cmd_name in ('foo', 'info'):
288
294
                return ACommand()
289
295
        commands.Command.hooks.install_named_hook(
290
296
            "get_missing_command", get_missing_cmd, None)
 
297
        self.ACommand = ACommand
 
298
 
 
299
    def test_fires_on_get_cmd_object(self):
 
300
        # The get_missing_command(cmd) hook fires when commands are delivered to the
 
301
        # ui.
 
302
        self.hook_missing()
291
303
        # create a command directly, should not fire
292
 
        cmd = ACommand()
293
 
        self.assertEqual([], hook_calls)
 
304
        self.cmd = self.ACommand()
 
305
        self.assertEqual([], self.hook_calls)
294
306
        # ask by name, should fire and give us our command
295
307
        cmd = commands.get_cmd_object('foo')
296
 
        self.assertEqual([('called', 'foo')], hook_calls)
297
 
        self.assertIsInstance(cmd, ACommand)
298
 
        del hook_calls[:]
 
308
        self.assertEqual([('called', 'foo')], self.hook_calls)
 
309
        self.assertIsInstance(cmd, self.ACommand)
 
310
        del self.hook_calls[:]
299
311
        # ask by a name that is supplied by a builtin - the hook should not
300
312
        # fire and we still get our object.
301
313
        commands.install_bzr_command_hooks()
302
314
        cmd = commands.get_cmd_object('info')
303
315
        self.assertNotEqual(None, cmd)
304
 
        self.assertEqual(0, len(hook_calls))
 
316
        self.assertEqual(0, len(self.hook_calls))
 
317
 
 
318
    def test_skipped_on_HelpCommandIndex_get_topics(self):
 
319
        # The get_missing_command(cmd_name) hook is not fired when
 
320
        # looking up help topics.
 
321
        self.hook_missing()
 
322
        topic = commands.HelpCommandIndex()
 
323
        topics = topic.get_topics('foo')
 
324
        self.assertEqual([], self.hook_calls)
305
325
 
306
326
 
307
327
class TestListCommandHook(tests.TestCase):
323
343
        cmds = list(commands.all_command_names())
324
344
        self.assertEqual(['called'], hook_calls)
325
345
        self.assertSubset(['foo', 'bar'], cmds)
 
346
 
 
347
 
 
348
class TestDeprecations(tests.TestCase):
 
349
 
 
350
    def test_shlex_split_unicode_deprecation(self):
 
351
        res = self.applyDeprecated(
 
352
                symbol_versioning.deprecated_in((2, 2, 0)),
 
353
                commands.shlex_split_unicode, 'whatever')