1
# Copyright (C) 2005-2012, 2016 Canonical Ltd
1
# Copyright (C) 2004, 2005 by Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
from bzrlib.tests import TestCase
18
from bzrlib.commands import display_command
30
from ..commands import display_command
31
from . import TestSkipped
34
class TestCommands(tests.TestCase):
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)
43
if not cmd_help or cmd_help == base_doc:
44
commands_without_help.append(cmd_name)
45
self.assertLength(0, commands_without_help)
21
class TestCommands(TestCase):
47
22
def test_display_command(self):
48
23
"""EPIPE message is selectively suppressed"""
49
24
def pipe_thrower():
50
25
raise IOError(errno.EPIPE, "Bogus pipe error")
51
26
self.assertRaises(IOError, pipe_thrower)
59
32
def other_thrower():
60
33
raise IOError(errno.ESPIPE, "Bogus pipe error")
61
34
self.assertRaises(IOError, other_thrower)
63
def test_unicode_command(self):
64
# This error is thrown when we can't find the command in the
65
# list of available commands
66
self.assertRaises(errors.BzrCommandError,
67
commands.run_bzr, [u'cmd\xb5'])
69
def test_unicode_option(self):
70
# This error is actually thrown by optparse, when it
71
# can't find the given option
73
if optparse.__version__ == "1.5.3":
74
raise TestSkipped("optparse 1.5.3 can't handle unicode options")
75
self.assertRaises(errors.BzrCommandError,
76
commands.run_bzr, ['log', u'--option\xb5'])
79
def get_command(options):
80
class cmd_foo(commands.Command):
83
takes_options = options
87
def test_help_hidden(self):
88
c = self.get_command([option.Option('foo', hidden=True)])
89
self.assertNotContainsRe(c.get_help_text(), '--foo')
91
def test_help_not_hidden(self):
92
c = self.get_command([option.Option('foo', hidden=False)])
93
self.assertContainsRe(c.get_help_text(), '--foo')
96
class TestInsideCommand(tests.TestCaseInTempDir):
98
def test_command_see_config_overrides(self):
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'))
113
class TestInvokedAs(tests.TestCase):
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')
125
class TestGetAlias(tests.TestCase):
127
def _get_config(self, config_text):
128
my_config = config.GlobalConfig.from_string(config_text)
131
def test_simple(self):
132
my_config = self._get_config("[ALIASES]\n"
133
"diff=diff -r -2..-1\n")
134
self.assertEqual([u'diff', u'-r', u'-2..-1'],
135
commands.get_alias("diff", config=my_config))
137
def test_single_quotes(self):
138
my_config = self._get_config("[ALIASES]\n"
139
"diff=diff -r -2..-1 --diff-options "
140
"'--strip-trailing-cr -wp'\n")
141
self.assertEqual([u'diff', u'-r', u'-2..-1', u'--diff-options',
142
u'--strip-trailing-cr -wp'],
143
commands.get_alias("diff", config=my_config))
145
def test_double_quotes(self):
146
my_config = self._get_config("[ALIASES]\n"
147
"diff=diff -r -2..-1 --diff-options "
148
"\"--strip-trailing-cr -wp\"\n")
149
self.assertEqual([u'diff', u'-r', u'-2..-1', u'--diff-options',
150
u'--strip-trailing-cr -wp'],
151
commands.get_alias("diff", config=my_config))
153
def test_unicode(self):
154
my_config = self._get_config("[ALIASES]\n"
155
u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
156
self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
157
commands.get_alias("iam", config=my_config))
160
class TestSeeAlso(tests.TestCase):
161
"""Tests for the see also functional of Command."""
164
def _get_command_with_see_also(see_also):
165
class ACommand(commands.Command):
166
__doc__ = """A sample command."""
170
def test_default_subclass_no_see_also(self):
171
command = self._get_command_with_see_also([])
172
self.assertEqual([], command.get_see_also())
174
def test__see_also(self):
175
"""When _see_also is defined, it sets the result of get_see_also()."""
176
command = self._get_command_with_see_also(['bar', 'foo'])
177
self.assertEqual(['bar', 'foo'], command.get_see_also())
179
def test_deduplication(self):
180
"""Duplicates in _see_also are stripped out."""
181
command = self._get_command_with_see_also(['foo', 'foo'])
182
self.assertEqual(['foo'], command.get_see_also())
184
def test_sorted(self):
185
"""_see_also is sorted by get_see_also."""
186
command = self._get_command_with_see_also(['foo', 'bar'])
187
self.assertEqual(['bar', 'foo'], command.get_see_also())
189
def test_additional_terms(self):
190
"""Additional terms can be supplied and are deduped and sorted."""
191
command = self._get_command_with_see_also(['foo', 'bar'])
192
self.assertEqual(['bar', 'foo', 'gam'],
193
command.get_see_also(['gam', 'bar', 'gam']))
196
class TestRegisterLazy(tests.TestCase):
199
super(TestRegisterLazy, self).setUp()
200
import breezy.tests.fake_command
201
del sys.modules['breezy.tests.fake_command']
202
global lazy_command_imported
203
lazy_command_imported = False
204
commands.install_bzr_command_hooks()
208
commands.plugin_cmds.remove('fake')
210
def assertIsFakeCommand(self, cmd_obj):
211
from breezy.tests.fake_command import cmd_fake
212
self.assertIsInstance(cmd_obj, cmd_fake)
214
def test_register_lazy(self):
215
"""Ensure lazy registration works"""
216
commands.plugin_cmds.register_lazy('cmd_fake', [],
217
'breezy.tests.fake_command')
218
self.addCleanup(self.remove_fake)
219
self.assertFalse(lazy_command_imported)
220
fake_instance = commands.get_cmd_object('fake')
221
self.assertTrue(lazy_command_imported)
222
self.assertIsFakeCommand(fake_instance)
224
def test_get_unrelated_does_not_import(self):
225
commands.plugin_cmds.register_lazy('cmd_fake', [],
226
'breezy.tests.fake_command')
227
self.addCleanup(self.remove_fake)
228
commands.get_cmd_object('status')
229
self.assertFalse(lazy_command_imported)
231
def test_aliases(self):
232
commands.plugin_cmds.register_lazy('cmd_fake', ['fake_alias'],
233
'breezy.tests.fake_command')
234
self.addCleanup(self.remove_fake)
235
fake_instance = commands.get_cmd_object('fake_alias')
236
self.assertIsFakeCommand(fake_instance)
239
class TestExtendCommandHook(tests.TestCase):
241
def test_fires_on_get_cmd_object(self):
242
# The extend_command(cmd) hook fires when commands are delivered to the
243
# ui, not simply at registration (because lazy registered plugin
244
# commands are registered).
245
# when they are simply created.
247
commands.install_bzr_command_hooks()
248
commands.Command.hooks.install_named_hook(
249
"extend_command", hook_calls.append, None)
250
# create a command, should not fire
252
class cmd_test_extend_command_hook(commands.Command):
253
__doc__ = """A sample command."""
254
self.assertEqual([], hook_calls)
256
# register the command class, should not fire
258
commands.builtin_command_registry.register(
259
cmd_test_extend_command_hook)
260
self.assertEqual([], hook_calls)
261
# and ask for the object, should fire
262
cmd = commands.get_cmd_object('test-extend-command-hook')
263
# For resilience - to ensure all code paths hit it - we
264
# fire on everything returned in the 'cmd_dict', which is currently
265
# all known commands, so assert that cmd is in hook_calls
266
self.assertSubset([cmd], hook_calls)
269
commands.builtin_command_registry.remove(
270
'test-extend-command-hook')
271
# -- as a plugin lazy registration
273
# register the command class, should not fire
274
commands.plugin_cmds.register_lazy('cmd_fake', [],
275
'breezy.tests.fake_command')
276
self.assertEqual([], hook_calls)
277
# and ask for the object, should fire
278
cmd = commands.get_cmd_object('fake')
279
self.assertEqual([cmd], hook_calls)
281
commands.plugin_cmds.remove('fake')
284
class TestGetCommandHook(tests.TestCase):
286
def test_fires_on_get_cmd_object(self):
287
# The get_command(cmd) hook fires when commands are delivered to the
289
commands.install_bzr_command_hooks()
292
class ACommand(commands.Command):
293
__doc__ = """A sample command."""
295
def get_cmd(cmd_or_None, cmd_name):
296
hook_calls.append(('called', cmd_or_None, cmd_name))
297
if cmd_name in ('foo', 'info'):
299
commands.Command.hooks.install_named_hook(
300
"get_command", get_cmd, None)
301
# create a command directly, should not fire
303
self.assertEqual([], hook_calls)
304
# ask by name, should fire and give us our command
305
cmd = commands.get_cmd_object('foo')
306
self.assertEqual([('called', None, 'foo')], hook_calls)
307
self.assertIsInstance(cmd, ACommand)
309
# ask by a name that is supplied by a builtin - the hook should still
310
# fire and we still get our object, but we should see the builtin
311
# passed to the hook.
312
cmd = commands.get_cmd_object('info')
313
self.assertIsInstance(cmd, ACommand)
314
self.assertEqual(1, len(hook_calls))
315
self.assertEqual('info', hook_calls[0][2])
316
self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
319
class TestCommandNotFound(tests.TestCase):
322
super(TestCommandNotFound, self).setUp()
323
commands._register_builtin_commands()
324
commands.install_bzr_command_hooks()
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))
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"',
338
class TestGetMissingCommandHook(tests.TestCase):
340
def hook_missing(self):
341
"""Hook get_missing_command for testing."""
344
class ACommand(commands.Command):
345
__doc__ = """A sample command."""
347
def get_missing_cmd(cmd_name):
348
self.hook_calls.append(('called', cmd_name))
349
if cmd_name in ('foo', 'info'):
351
commands.Command.hooks.install_named_hook(
352
"get_missing_command", get_missing_cmd, None)
353
self.ACommand = ACommand
355
def test_fires_on_get_cmd_object(self):
356
# The get_missing_command(cmd) hook fires when commands are delivered to the
359
# create a command directly, should not fire
360
self.cmd = self.ACommand()
361
self.assertEqual([], self.hook_calls)
362
# ask by name, should fire and give us our command
363
cmd = commands.get_cmd_object('foo')
364
self.assertEqual([('called', 'foo')], self.hook_calls)
365
self.assertIsInstance(cmd, self.ACommand)
366
del self.hook_calls[:]
367
# ask by a name that is supplied by a builtin - the hook should not
368
# fire and we still get our object.
369
commands.install_bzr_command_hooks()
370
cmd = commands.get_cmd_object('info')
371
self.assertNotEqual(None, cmd)
372
self.assertEqual(0, len(self.hook_calls))
374
def test_skipped_on_HelpCommandIndex_get_topics(self):
375
# The get_missing_command(cmd_name) hook is not fired when
376
# looking up help topics.
378
topic = commands.HelpCommandIndex()
379
topics = topic.get_topics('foo')
380
self.assertEqual([], self.hook_calls)
383
class TestListCommandHook(tests.TestCase):
385
def test_fires_on_all_command_names(self):
386
# The list_commands() hook fires when all_command_names() is invoked.
388
commands.install_bzr_command_hooks()
390
def list_my_commands(cmd_names):
391
hook_calls.append('called')
392
cmd_names.update(['foo', 'bar'])
394
commands.Command.hooks.install_named_hook(
395
"list_commands", list_my_commands, None)
396
# Get a command, which should not trigger the hook.
397
cmd = commands.get_cmd_object('info')
398
self.assertEqual([], hook_calls)
399
# Get all command classes (for docs and shell completion).
400
cmds = list(commands.all_command_names())
401
self.assertEqual(['called'], hook_calls)
402
self.assertSubset(['foo', 'bar'], cmds)
405
class TestPreAndPostCommandHooks(tests.TestCase):
406
class TestError(Exception):
407
__doc__ = """A test exception."""
409
def test_pre_and_post_hooks(self):
412
def pre_command(cmd):
413
self.assertEqual([], hook_calls)
414
hook_calls.append('pre')
416
def post_command(cmd):
417
self.assertEqual(['pre', 'run'], hook_calls)
418
hook_calls.append('post')
421
self.assertEqual(['pre'], hook_calls)
422
hook_calls.append('run')
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)
431
self.assertEqual([], hook_calls)
432
self.run_bzr(['rocks', '-Oxx=12', '-Oyy=foo'])
433
self.assertEqual(['pre', 'run', 'post'], hook_calls)
435
def test_post_hook_provided_exception(self):
438
def post_command(cmd):
439
hook_calls.append('post')
442
hook_calls.append('run')
443
raise self.TestError()
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)
450
self.assertEqual([], hook_calls)
451
self.assertRaises(self.TestError, commands.run_bzr, [u'rocks'])
452
self.assertEqual(['run', 'post'], hook_calls)
454
def test_pre_command_error(self):
455
"""Ensure an BzrCommandError in pre_command aborts the command"""
459
def pre_command(cmd):
460
hook_calls.append('pre')
461
# verify that all subclasses of BzrCommandError caught too
462
raise commands.BzrOptionError()
464
def post_command(cmd, e):
465
self.fail('post_command should not be called')
468
self.fail('command should not be called')
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)
477
self.assertEqual([], hook_calls)
478
self.assertRaises(errors.BzrCommandError,
479
commands.run_bzr, [u'rocks'])
480
self.assertEqual(['pre'], hook_calls)
483
class GuessCommandTests(tests.TestCase):
486
super(GuessCommandTests, self).setUp()
487
commands._register_builtin_commands()
488
commands.install_bzr_command_hooks()
490
def test_guess_override(self):
491
self.assertEqual('ci', commands.guess_command('ic'))
493
def test_guess(self):
494
commands.get_cmd_object('status')
495
self.assertEqual('status', commands.guess_command('statue'))
498
self.assertIs(None, commands.guess_command('nothingisevenclose'))
added
removed
bzrlib/tests/test_command.py
