← 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-29 22:03:03 UTC
  • mfrom: (5416.2.6 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100929220303-cr95h8iwtggco721
(mbp) Add 'break-lock --force'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_commands.py
1
 
# Copyright (C) 2005-2011 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
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
17
18
import errno
18
19
import inspect
19
20
import sys
24
25
    config,
25
26
    errors,
26
27
    option,
 
28
    symbol_versioning,
27
29
    tests,
28
 
    trace,
29
30
    )
30
31
from bzrlib.commands import display_command
31
32
from bzrlib.tests import TestSkipped
91
92
        self.assertContainsRe(c.get_help_text(), '--foo')
92
93
 
93
94
 
94
 
class TestInsideCommand(tests.TestCaseInTempDir):
95
 
 
96
 
    def test_command_see_config_overrides(self):
97
 
        def run(cmd):
98
 
            # We override the run() command method so we can observe the
99
 
            # overrides from inside.
100
 
            c = config.GlobalStack()
101
 
            self.assertEquals('12', c.get('xx'))
102
 
            self.assertEquals('foo', c.get('yy'))
103
 
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
104
 
        self.run_bzr(['rocks', '-Oxx=12', '-Oyy=foo'])
105
 
        c = config.GlobalStack()
106
 
        # Ensure that we don't leak outside of the command
107
 
        self.assertEquals(None, c.get('xx'))
108
 
        self.assertEquals(None, c.get('yy'))
109
 
 
110
 
 
111
 
class TestInvokedAs(tests.TestCase):
112
 
 
113
 
    def test_invoked_as(self):
114
 
        """The command object knows the actual name used to invoke it."""
115
 
        commands.install_bzr_command_hooks()
116
 
        commands._register_builtin_commands()
117
 
        # get one from the real get_cmd_object.
118
 
        c = commands.get_cmd_object('ci')
119
 
        self.assertIsInstance(c, builtins.cmd_commit)
120
 
        self.assertEquals(c.invoked_as, 'ci')
121
 
 
122
 
 
123
95
class TestGetAlias(tests.TestCase):
124
96
 
125
97
    def _get_config(self, config_text):
194
166
class TestRegisterLazy(tests.TestCase):
195
167
 
196
168
    def setUp(self):
197
 
        super(TestRegisterLazy, self).setUp()
 
169
        tests.TestCase.setUp(self)
198
170
        import bzrlib.tests.fake_command
199
171
        del sys.modules['bzrlib.tests.fake_command']
200
172
        global lazy_command_imported
372
344
        self.assertEqual(['called'], hook_calls)
373
345
        self.assertSubset(['foo', 'bar'], cmds)
374
346
 
375
 
class TestPreAndPostCommandHooks(tests.TestCase):
376
 
    class TestError(StandardError):
377
 
        __doc__ = """A test exception."""
378
 
 
379
 
    def test_pre_and_post_hooks(self):
380
 
        hook_calls = []
381
 
 
382
 
        def pre_command(cmd):
383
 
            self.assertEqual([], hook_calls)
384
 
            hook_calls.append('pre')
385
 
 
386
 
        def post_command(cmd):
387
 
            self.assertEqual(['pre', 'run'], hook_calls)
388
 
            hook_calls.append('post')
389
 
 
390
 
        def run(cmd):
391
 
            self.assertEqual(['pre'], hook_calls)
392
 
            hook_calls.append('run')
393
 
 
394
 
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
395
 
        commands.install_bzr_command_hooks()
396
 
        commands.Command.hooks.install_named_hook(
397
 
            "pre_command", pre_command, None)
398
 
        commands.Command.hooks.install_named_hook(
399
 
            "post_command", post_command, None)
400
 
 
401
 
        self.assertEqual([], hook_calls)
402
 
        self.run_bzr(['rocks', '-Oxx=12', '-Oyy=foo'])
403
 
        self.assertEqual(['pre', 'run', 'post'], hook_calls)
404
 
 
405
 
    def test_post_hook_provided_exception(self):
406
 
        hook_calls = []
407
 
 
408
 
        def post_command(cmd):
409
 
            hook_calls.append('post')
410
 
 
411
 
        def run(cmd):
412
 
            hook_calls.append('run')
413
 
            raise self.TestError()
414
 
 
415
 
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
416
 
        commands.install_bzr_command_hooks()
417
 
        commands.Command.hooks.install_named_hook(
418
 
            "post_command", post_command, None)
419
 
 
420
 
        self.assertEqual([], hook_calls)
421
 
        self.assertRaises(self.TestError, commands.run_bzr, [u'rocks'])
422
 
        self.assertEqual(['run', 'post'], hook_calls)
423
 
 
424
 
    def test_pre_command_error(self):
425
 
        """Ensure an BzrCommandError in pre_command aborts the command"""
426
 
 
427
 
        hook_calls = []
428
 
 
429
 
        def pre_command(cmd):
430
 
            hook_calls.append('pre')
431
 
            # verify that all subclasses of BzrCommandError caught too
432
 
            raise errors.BzrOptionError()
433
 
 
434
 
        def post_command(cmd, e):
435
 
            self.fail('post_command should not be called')
436
 
 
437
 
        def run(cmd):
438
 
            self.fail('command should not be called')
439
 
 
440
 
        self.overrideAttr(builtins.cmd_rocks, 'run', run)
441
 
        commands.install_bzr_command_hooks()
442
 
        commands.Command.hooks.install_named_hook(
443
 
            "pre_command", pre_command, None)
444
 
        commands.Command.hooks.install_named_hook(
445
 
            "post_command", post_command, None)
446
 
 
447
 
        self.assertEqual([], hook_calls)
448
 
        self.assertRaises(errors.BzrCommandError,
449
 
                          commands.run_bzr, [u'rocks'])
450
 
        self.assertEqual(['pre'], hook_calls)
451
 
 
 
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')