← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_commands.py

Cleanup asserts

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 (
24
23
    commands,
25
24
    config,
26
25
    errors,
27
 
    option,
28
 
    symbol_versioning,
29
26
    tests,
30
27
    )
31
28
from bzrlib.commands import display_command
34
31
 
35
32
class TestCommands(tests.TestCase):
36
33
 
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
34
    def test_display_command(self):
49
35
        """EPIPE message is selectively suppressed"""
50
36
        def pipe_thrower():
74
60
        self.assertRaises(errors.BzrCommandError,
75
61
                          commands.run_bzr, ['log', u'--option\xb5'])
76
62
 
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
 
 
94
63
 
95
64
class TestGetAlias(tests.TestCase):
96
65
 
97
66
    def _get_config(self, config_text):
98
 
        my_config = config.GlobalConfig.from_string(config_text)
 
67
        my_config = config.GlobalConfig()
 
68
        config_file = StringIO(config_text.encode('utf-8'))
 
69
        my_config._parser = my_config._get_parser(file=config_file)
99
70
        return my_config
100
71
 
101
72
    def test_simple(self):
122
93
 
123
94
    def test_unicode(self):
124
95
        my_config = self._get_config("[ALIASES]\n"
125
 
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
 
96
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
126
97
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
127
98
                          commands.get_alias("iam", config=my_config))
128
99
 
130
101
class TestSeeAlso(tests.TestCase):
131
102
    """Tests for the see also functional of Command."""
132
103
 
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
104
    def test_default_subclass_no_see_also(self):
141
 
        command = self._get_command_with_see_also([])
 
105
        class ACommand(commands.Command):
 
106
            """A sample command."""
 
107
        command = ACommand()
142
108
        self.assertEqual([], command.get_see_also())
143
109
 
144
110
    def test__see_also(self):
145
111
        """When _see_also is defined, it sets the result of get_see_also()."""
146
 
        command = self._get_command_with_see_also(['bar', 'foo'])
 
112
        class ACommand(commands.Command):
 
113
            _see_also = ['bar', 'foo']
 
114
        command = ACommand()
147
115
        self.assertEqual(['bar', 'foo'], command.get_see_also())
148
116
 
149
117
    def test_deduplication(self):
150
118
        """Duplicates in _see_also are stripped out."""
151
 
        command = self._get_command_with_see_also(['foo', 'foo'])
 
119
        class ACommand(commands.Command):
 
120
            _see_also = ['foo', 'foo']
 
121
        command = ACommand()
152
122
        self.assertEqual(['foo'], command.get_see_also())
153
123
 
154
124
    def test_sorted(self):
155
125
        """_see_also is sorted by get_see_also."""
156
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
126
        class ACommand(commands.Command):
 
127
            _see_also = ['foo', 'bar']
 
128
        command = ACommand()
157
129
        self.assertEqual(['bar', 'foo'], command.get_see_also())
158
130
 
159
131
    def test_additional_terms(self):
160
132
        """Additional terms can be supplied and are deduped and sorted."""
161
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
133
        class ACommand(commands.Command):
 
134
            _see_also = ['foo', 'bar']
 
135
        command = ACommand()
162
136
        self.assertEqual(['bar', 'foo', 'gam'],
163
137
            command.get_see_also(['gam', 'bar', 'gam']))
164
138
 
171
145
        del sys.modules['bzrlib.tests.fake_command']
172
146
        global lazy_command_imported
173
147
        lazy_command_imported = False
174
 
        commands.install_bzr_command_hooks()
175
148
 
176
149
    @staticmethod
177
150
    def remove_fake():
214
187
        # commands are registered).
215
188
        # when they are simply created.
216
189
        hook_calls = []
217
 
        commands.install_bzr_command_hooks()
218
190
        commands.Command.hooks.install_named_hook(
219
191
            "extend_command", hook_calls.append, None)
220
192
        # create a command, should not fire
221
 
        class cmd_test_extend_command_hook(commands.Command):
222
 
            __doc__ = """A sample command."""
 
193
        class ACommand(commands.Command):
 
194
            """A sample command."""
 
195
        cmd = ACommand()
223
196
        self.assertEqual([], hook_calls)
224
197
        # -- as a builtin
225
198
        # register the command class, should not fire
226
199
        try:
227
 
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
 
200
            builtins.cmd_test_extend_command_hook = ACommand
228
201
            self.assertEqual([], hook_calls)
229
202
            # and ask for the object, should fire
230
203
            cmd = commands.get_cmd_object('test-extend-command-hook')
234
207
            self.assertSubset([cmd], hook_calls)
235
208
            del hook_calls[:]
236
209
        finally:
237
 
            commands.builtin_command_registry.remove('test-extend-command-hook')
 
210
            del builtins.cmd_test_extend_command_hook
238
211
        # -- as a plugin lazy registration
239
212
        try:
240
213
            # register the command class, should not fire
246
219
            self.assertEqual([cmd], hook_calls)
247
220
        finally:
248
221
            commands.plugin_cmds.remove('fake')
249
 
 
250
 
 
251
 
class TestGetCommandHook(tests.TestCase):
252
 
 
253
 
    def test_fires_on_get_cmd_object(self):
254
 
        # The get_command(cmd) hook fires when commands are delivered to the
255
 
        # ui.
256
 
        commands.install_bzr_command_hooks()
257
 
        hook_calls = []
258
 
        class ACommand(commands.Command):
259
 
            __doc__ = """A sample command."""
260
 
        def get_cmd(cmd_or_None, cmd_name):
261
 
            hook_calls.append(('called', cmd_or_None, cmd_name))
262
 
            if cmd_name in ('foo', 'info'):
263
 
                return ACommand()
264
 
        commands.Command.hooks.install_named_hook(
265
 
            "get_command", get_cmd, None)
266
 
        # create a command directly, should not fire
267
 
        cmd = ACommand()
268
 
        self.assertEqual([], hook_calls)
269
 
        # ask by name, should fire and give us our command
270
 
        cmd = commands.get_cmd_object('foo')
271
 
        self.assertEqual([('called', None, 'foo')], hook_calls)
272
 
        self.assertIsInstance(cmd, ACommand)
273
 
        del hook_calls[:]
274
 
        # ask by a name that is supplied by a builtin - the hook should still
275
 
        # fire and we still get our object, but we should see the builtin
276
 
        # passed to the hook.
277
 
        cmd = commands.get_cmd_object('info')
278
 
        self.assertIsInstance(cmd, ACommand)
279
 
        self.assertEqual(1, len(hook_calls))
280
 
        self.assertEqual('info', hook_calls[0][2])
281
 
        self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
282
 
 
283
 
 
284
 
class TestGetMissingCommandHook(tests.TestCase):
285
 
 
286
 
    def hook_missing(self):
287
 
        """Hook get_missing_command for testing."""
288
 
        self.hook_calls = []
289
 
        class ACommand(commands.Command):
290
 
            __doc__ = """A sample command."""
291
 
        def get_missing_cmd(cmd_name):
292
 
            self.hook_calls.append(('called', cmd_name))
293
 
            if cmd_name in ('foo', 'info'):
294
 
                return ACommand()
295
 
        commands.Command.hooks.install_named_hook(
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()
303
 
        # create a command directly, should not fire
304
 
        self.cmd = self.ACommand()
305
 
        self.assertEqual([], self.hook_calls)
306
 
        # ask by name, should fire and give us our command
307
 
        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[:]
311
 
        # ask by a name that is supplied by a builtin - the hook should not
312
 
        # fire and we still get our object.
313
 
        commands.install_bzr_command_hooks()
314
 
        cmd = commands.get_cmd_object('info')
315
 
        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)
325
 
 
326
 
 
327
 
class TestListCommandHook(tests.TestCase):
328
 
 
329
 
    def test_fires_on_all_command_names(self):
330
 
        # The list_commands() hook fires when all_command_names() is invoked.
331
 
        hook_calls = []
332
 
        commands.install_bzr_command_hooks()
333
 
        def list_my_commands(cmd_names):
334
 
            hook_calls.append('called')
335
 
            cmd_names.update(['foo', 'bar'])
336
 
            return cmd_names
337
 
        commands.Command.hooks.install_named_hook(
338
 
            "list_commands", list_my_commands, None)
339
 
        # Get a command, which should not trigger the hook.
340
 
        cmd = commands.get_cmd_object('info')
341
 
        self.assertEqual([], hook_calls)
342
 
        # Get all command classes (for docs and shell completion).
343
 
        cmds = list(commands.all_command_names())
344
 
        self.assertEqual(['called'], hook_calls)
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')