/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_commands.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_commands.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
17
import errno
 
18
import inspect
19
19
import sys
20
20
 
21
 
from bzrlib import (
 
21
from .. import (
22
22
    builtins,
23
23
    commands,
24
24
    config,
25
25
    errors,
26
26
    option,
27
 
    symbol_versioning,
28
27
    tests,
 
28
    trace,
29
29
    )
30
 
from bzrlib.commands import display_command
31
 
from bzrlib.tests import TestSkipped
 
30
from ..commands import display_command
 
31
from . import TestSkipped
32
32
 
33
33
 
34
34
class TestCommands(tests.TestCase):
35
35
 
 
36
    def test_all_commands_have_help(self):
 
37
        commands._register_builtin_commands()
 
38
        commands_without_help = set()
 
39
        base_doc = inspect.getdoc(commands.Command)
 
40
        for cmd_name in commands.all_command_names():
 
41
            cmd = commands.get_cmd_object(cmd_name)
 
42
            cmd_help = cmd.help()
 
43
            if not cmd_help or cmd_help == base_doc:
 
44
                commands_without_help.append(cmd_name)
 
45
        self.assertLength(0, commands_without_help)
 
46
 
36
47
    def test_display_command(self):
37
48
        """EPIPE message is selectively suppressed"""
38
49
        def pipe_thrower():
39
50
            raise IOError(errno.EPIPE, "Bogus pipe error")
40
51
        self.assertRaises(IOError, pipe_thrower)
 
52
 
41
53
        @display_command
42
54
        def non_thrower():
43
55
            pipe_thrower()
44
56
        non_thrower()
 
57
 
45
58
        @display_command
46
59
        def other_thrower():
47
60
            raise IOError(errno.ESPIPE, "Bogus pipe error")
80
93
        self.assertContainsRe(c.get_help_text(), '--foo')
81
94
 
82
95
 
 
96
class TestInsideCommand(tests.TestCaseInTempDir):
 
97
 
 
98
    def test_command_see_config_overrides(self):
 
99
        def run(cmd):
 
100
            # We override the run() command method so we can observe the
 
101
            # overrides from inside.
 
102
            c = config.GlobalStack()
 
103
            self.assertEqual('12', c.get('xx'))
 
104
            self.assertEqual('foo', c.get('yy'))
 
105
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
 
106
        self.run_bzr(['rocks', '-Oxx=12', '-Oyy=foo'])
 
107
        c = config.GlobalStack()
 
108
        # Ensure that we don't leak outside of the command
 
109
        self.assertEqual(None, c.get('xx'))
 
110
        self.assertEqual(None, c.get('yy'))
 
111
 
 
112
 
 
113
class TestInvokedAs(tests.TestCase):
 
114
 
 
115
    def test_invoked_as(self):
 
116
        """The command object knows the actual name used to invoke it."""
 
117
        commands.install_bzr_command_hooks()
 
118
        commands._register_builtin_commands()
 
119
        # get one from the real get_cmd_object.
 
120
        c = commands.get_cmd_object('ci')
 
121
        self.assertIsInstance(c, builtins.cmd_commit)
 
122
        self.assertEqual(c.invoked_as, 'ci')
 
123
 
 
124
 
83
125
class TestGetAlias(tests.TestCase):
84
126
 
85
127
    def _get_config(self, config_text):
86
 
        my_config = config.GlobalConfig()
87
 
        config_file = StringIO(config_text.encode('utf-8'))
88
 
        my_config._parser = my_config._get_parser(file=config_file)
 
128
        my_config = config.GlobalConfig.from_string(config_text)
89
129
        return my_config
90
130
 
91
131
    def test_simple(self):
92
132
        my_config = self._get_config("[ALIASES]\n"
93
 
            "diff=diff -r -2..-1\n")
 
133
                                     "diff=diff -r -2..-1\n")
94
134
        self.assertEqual([u'diff', u'-r', u'-2..-1'],
95
 
            commands.get_alias("diff", config=my_config))
 
135
                         commands.get_alias("diff", config=my_config))
96
136
 
97
137
    def test_single_quotes(self):
98
138
        my_config = self._get_config("[ALIASES]\n"
99
 
            "diff=diff -r -2..-1 --diff-options "
100
 
            "'--strip-trailing-cr -wp'\n")
 
139
                                     "diff=diff -r -2..-1 --diff-options "
 
140
                                     "'--strip-trailing-cr -wp'\n")
101
141
        self.assertEqual([u'diff', u'-r', u'-2..-1', u'--diff-options',
102
142
                          u'--strip-trailing-cr -wp'],
103
 
                          commands.get_alias("diff", config=my_config))
 
143
                         commands.get_alias("diff", config=my_config))
104
144
 
105
145
    def test_double_quotes(self):
106
146
        my_config = self._get_config("[ALIASES]\n"
107
 
            "diff=diff -r -2..-1 --diff-options "
108
 
            "\"--strip-trailing-cr -wp\"\n")
 
147
                                     "diff=diff -r -2..-1 --diff-options "
 
148
                                     "\"--strip-trailing-cr -wp\"\n")
109
149
        self.assertEqual([u'diff', u'-r', u'-2..-1', u'--diff-options',
110
150
                          u'--strip-trailing-cr -wp'],
111
 
                          commands.get_alias("diff", config=my_config))
 
151
                         commands.get_alias("diff", config=my_config))
112
152
 
113
153
    def test_unicode(self):
114
154
        my_config = self._get_config("[ALIASES]\n"
115
 
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
 
155
                                     u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
116
156
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
117
 
                          commands.get_alias("iam", config=my_config))
 
157
                         commands.get_alias("iam", config=my_config))
118
158
 
119
159
 
120
160
class TestSeeAlso(tests.TestCase):
150
190
        """Additional terms can be supplied and are deduped and sorted."""
151
191
        command = self._get_command_with_see_also(['foo', 'bar'])
152
192
        self.assertEqual(['bar', 'foo', 'gam'],
153
 
            command.get_see_also(['gam', 'bar', 'gam']))
 
193
                         command.get_see_also(['gam', 'bar', 'gam']))
154
194
 
155
195
 
156
196
class TestRegisterLazy(tests.TestCase):
157
197
 
158
198
    def setUp(self):
159
 
        tests.TestCase.setUp(self)
160
 
        import bzrlib.tests.fake_command
161
 
        del sys.modules['bzrlib.tests.fake_command']
 
199
        super(TestRegisterLazy, self).setUp()
 
200
        import breezy.tests.fake_command
 
201
        del sys.modules['breezy.tests.fake_command']
162
202
        global lazy_command_imported
163
203
        lazy_command_imported = False
164
204
        commands.install_bzr_command_hooks()
168
208
        commands.plugin_cmds.remove('fake')
169
209
 
170
210
    def assertIsFakeCommand(self, cmd_obj):
171
 
        from bzrlib.tests.fake_command import cmd_fake
 
211
        from breezy.tests.fake_command import cmd_fake
172
212
        self.assertIsInstance(cmd_obj, cmd_fake)
173
213
 
174
214
    def test_register_lazy(self):
175
215
        """Ensure lazy registration works"""
176
216
        commands.plugin_cmds.register_lazy('cmd_fake', [],
177
 
                                           'bzrlib.tests.fake_command')
 
217
                                           'breezy.tests.fake_command')
178
218
        self.addCleanup(self.remove_fake)
179
219
        self.assertFalse(lazy_command_imported)
180
220
        fake_instance = commands.get_cmd_object('fake')
183
223
 
184
224
    def test_get_unrelated_does_not_import(self):
185
225
        commands.plugin_cmds.register_lazy('cmd_fake', [],
186
 
                                           'bzrlib.tests.fake_command')
 
226
                                           'breezy.tests.fake_command')
187
227
        self.addCleanup(self.remove_fake)
188
228
        commands.get_cmd_object('status')
189
229
        self.assertFalse(lazy_command_imported)
190
230
 
191
231
    def test_aliases(self):
192
232
        commands.plugin_cmds.register_lazy('cmd_fake', ['fake_alias'],
193
 
                                           'bzrlib.tests.fake_command')
 
233
                                           'breezy.tests.fake_command')
194
234
        self.addCleanup(self.remove_fake)
195
235
        fake_instance = commands.get_cmd_object('fake_alias')
196
236
        self.assertIsFakeCommand(fake_instance)
208
248
        commands.Command.hooks.install_named_hook(
209
249
            "extend_command", hook_calls.append, None)
210
250
        # create a command, should not fire
 
251
 
211
252
        class cmd_test_extend_command_hook(commands.Command):
212
253
            __doc__ = """A sample command."""
213
254
        self.assertEqual([], hook_calls)
214
255
        # -- as a builtin
215
256
        # register the command class, should not fire
216
257
        try:
217
 
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
 
258
            commands.builtin_command_registry.register(
 
259
                cmd_test_extend_command_hook)
218
260
            self.assertEqual([], hook_calls)
219
261
            # and ask for the object, should fire
220
262
            cmd = commands.get_cmd_object('test-extend-command-hook')
224
266
            self.assertSubset([cmd], hook_calls)
225
267
            del hook_calls[:]
226
268
        finally:
227
 
            commands.builtin_command_registry.remove('test-extend-command-hook')
 
269
            commands.builtin_command_registry.remove(
 
270
                'test-extend-command-hook')
228
271
        # -- as a plugin lazy registration
229
272
        try:
230
273
            # register the command class, should not fire
231
274
            commands.plugin_cmds.register_lazy('cmd_fake', [],
232
 
                                               'bzrlib.tests.fake_command')
 
275
                                               'breezy.tests.fake_command')
233
276
            self.assertEqual([], hook_calls)
234
277
            # and ask for the object, should fire
235
278
            cmd = commands.get_cmd_object('fake')
245
288
        # ui.
246
289
        commands.install_bzr_command_hooks()
247
290
        hook_calls = []
 
291
 
248
292
        class ACommand(commands.Command):
249
293
            __doc__ = """A sample command."""
 
294
 
250
295
        def get_cmd(cmd_or_None, cmd_name):
251
296
            hook_calls.append(('called', cmd_or_None, cmd_name))
252
297
            if cmd_name in ('foo', 'info'):
271
316
        self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
272
317
 
273
318
 
 
319
class TestCommandNotFound(tests.TestCase):
 
320
 
 
321
    def setUp(self):
 
322
        super(TestCommandNotFound, self).setUp()
 
323
        commands._register_builtin_commands()
 
324
        commands.install_bzr_command_hooks()
 
325
 
 
326
    def test_not_found_no_suggestion(self):
 
327
        e = self.assertRaises(errors.BzrCommandError,
 
328
                              commands.get_cmd_object, 'idontexistand')
 
329
        self.assertEqual('unknown command "idontexistand"', str(e))
 
330
 
 
331
    def test_not_found_with_suggestion(self):
 
332
        e = self.assertRaises(errors.BzrCommandError,
 
333
                              commands.get_cmd_object, 'statue')
 
334
        self.assertEqual('unknown command "statue". Perhaps you meant "status"',
 
335
                         str(e))
 
336
 
 
337
 
274
338
class TestGetMissingCommandHook(tests.TestCase):
275
339
 
276
340
    def hook_missing(self):
277
341
        """Hook get_missing_command for testing."""
278
342
        self.hook_calls = []
 
343
 
279
344
        class ACommand(commands.Command):
280
345
            __doc__ = """A sample command."""
 
346
 
281
347
        def get_missing_cmd(cmd_name):
282
348
            self.hook_calls.append(('called', cmd_name))
283
349
            if cmd_name in ('foo', 'info'):
320
386
        # The list_commands() hook fires when all_command_names() is invoked.
321
387
        hook_calls = []
322
388
        commands.install_bzr_command_hooks()
 
389
 
323
390
        def list_my_commands(cmd_names):
324
391
            hook_calls.append('called')
325
392
            cmd_names.update(['foo', 'bar'])
334
401
        self.assertEqual(['called'], hook_calls)
335
402
        self.assertSubset(['foo', 'bar'], cmds)
336
403
 
337
 
class TestDeprecations(tests.TestCase):
338
 
 
339
 
    def test_shlex_split_unicode_deprecation(self):
340
 
        res = self.applyDeprecated(
341
 
                symbol_versioning.deprecated_in((2, 2, 0)),
342
 
                commands.shlex_split_unicode, 'whatever')
 
404
 
 
405
class TestPreAndPostCommandHooks(tests.TestCase):
 
406
    class TestError(Exception):
 
407
        __doc__ = """A test exception."""
 
408
 
 
409
    def test_pre_and_post_hooks(self):
 
410
        hook_calls = []
 
411
 
 
412
        def pre_command(cmd):
 
413
            self.assertEqual([], hook_calls)
 
414
            hook_calls.append('pre')
 
415
 
 
416
        def post_command(cmd):
 
417
            self.assertEqual(['pre', 'run'], hook_calls)
 
418
            hook_calls.append('post')
 
419
 
 
420
        def run(cmd):
 
421
            self.assertEqual(['pre'], hook_calls)
 
422
            hook_calls.append('run')
 
423
 
 
424
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
 
425
        commands.install_bzr_command_hooks()
 
426
        commands.Command.hooks.install_named_hook(
 
427
            "pre_command", pre_command, None)
 
428
        commands.Command.hooks.install_named_hook(
 
429
            "post_command", post_command, None)
 
430
 
 
431
        self.assertEqual([], hook_calls)
 
432
        self.run_bzr(['rocks', '-Oxx=12', '-Oyy=foo'])
 
433
        self.assertEqual(['pre', 'run', 'post'], hook_calls)
 
434
 
 
435
    def test_post_hook_provided_exception(self):
 
436
        hook_calls = []
 
437
 
 
438
        def post_command(cmd):
 
439
            hook_calls.append('post')
 
440
 
 
441
        def run(cmd):
 
442
            hook_calls.append('run')
 
443
            raise self.TestError()
 
444
 
 
445
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
 
446
        commands.install_bzr_command_hooks()
 
447
        commands.Command.hooks.install_named_hook(
 
448
            "post_command", post_command, None)
 
449
 
 
450
        self.assertEqual([], hook_calls)
 
451
        self.assertRaises(self.TestError, commands.run_bzr, [u'rocks'])
 
452
        self.assertEqual(['run', 'post'], hook_calls)
 
453
 
 
454
    def test_pre_command_error(self):
 
455
        """Ensure an BzrCommandError in pre_command aborts the command"""
 
456
 
 
457
        hook_calls = []
 
458
 
 
459
        def pre_command(cmd):
 
460
            hook_calls.append('pre')
 
461
            # verify that all subclasses of BzrCommandError caught too
 
462
            raise commands.BzrOptionError()
 
463
 
 
464
        def post_command(cmd, e):
 
465
            self.fail('post_command should not be called')
 
466
 
 
467
        def run(cmd):
 
468
            self.fail('command should not be called')
 
469
 
 
470
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
 
471
        commands.install_bzr_command_hooks()
 
472
        commands.Command.hooks.install_named_hook(
 
473
            "pre_command", pre_command, None)
 
474
        commands.Command.hooks.install_named_hook(
 
475
            "post_command", post_command, None)
 
476
 
 
477
        self.assertEqual([], hook_calls)
 
478
        self.assertRaises(errors.BzrCommandError,
 
479
                          commands.run_bzr, [u'rocks'])
 
480
        self.assertEqual(['pre'], hook_calls)
 
481
 
 
482
 
 
483
class GuessCommandTests(tests.TestCase):
 
484
 
 
485
    def setUp(self):
 
486
        super(GuessCommandTests, self).setUp()
 
487
        commands._register_builtin_commands()
 
488
        commands.install_bzr_command_hooks()
 
489
 
 
490
    def test_guess_override(self):
 
491
        self.assertEqual('ci', commands.guess_command('ic'))
 
492
 
 
493
    def test_guess(self):
 
494
        commands.get_cmd_object('status')
 
495
        self.assertEqual('status', commands.guess_command('statue'))
 
496
 
 
497
    def test_none(self):
 
498
        self.assertIs(None, commands.guess_command('nothingisevenclose'))