← 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: Danny van Heumen
  • Date: 2010-03-09 16:38:10 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309163810-ujn8hcx08f75nlf1
Refined test to make use of locking hooks and also validate if lock is truly a checkout-lock.

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