← 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: John Arbash Meinel
  • Date: 2009-12-08 21:37:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4885.
  • Revision ID: john@arbash-meinel.com-20091208213736-vje7ublg3xzp1bs2
Now that we return files directly from the working tree
the windows 'attrib' test needed to be updated.
If we used the working tree for both old and new, then the test wasn't
really testing what we expected, which was that the newly generated
content was readable.

But using basis_tree gets us that. Also, test that the content is
properly marked as readonly, and that we have available content from
the working tree.

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
24
24
    config,
25
25
    errors,
26
26
    option,
27
 
    symbol_versioning,
28
27
    tests,
29
28
    )
30
29
from bzrlib.commands import display_command
65
64
    @staticmethod
66
65
    def get_command(options):
67
66
        class cmd_foo(commands.Command):
68
 
            __doc__ = 'Bar'
 
67
            'Bar'
69
68
 
70
69
            takes_options = options
71
70
 
112
111
 
113
112
    def test_unicode(self):
114
113
        my_config = self._get_config("[ALIASES]\n"
115
 
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
 
114
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
116
115
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
117
116
                          commands.get_alias("iam", config=my_config))
118
117
 
120
119
class TestSeeAlso(tests.TestCase):
121
120
    """Tests for the see also functional of Command."""
122
121
 
123
 
    @staticmethod
124
 
    def _get_command_with_see_also(see_also):
125
 
        class ACommand(commands.Command):
126
 
            __doc__ = """A sample command."""
127
 
            _see_also = see_also
128
 
        return ACommand()
129
 
 
130
122
    def test_default_subclass_no_see_also(self):
131
 
        command = self._get_command_with_see_also([])
 
123
        class ACommand(commands.Command):
 
124
            """A sample command."""
 
125
        command = ACommand()
132
126
        self.assertEqual([], command.get_see_also())
133
127
 
134
128
    def test__see_also(self):
135
129
        """When _see_also is defined, it sets the result of get_see_also()."""
136
 
        command = self._get_command_with_see_also(['bar', 'foo'])
 
130
        class ACommand(commands.Command):
 
131
            _see_also = ['bar', 'foo']
 
132
        command = ACommand()
137
133
        self.assertEqual(['bar', 'foo'], command.get_see_also())
138
134
 
139
135
    def test_deduplication(self):
140
136
        """Duplicates in _see_also are stripped out."""
141
 
        command = self._get_command_with_see_also(['foo', 'foo'])
 
137
        class ACommand(commands.Command):
 
138
            _see_also = ['foo', 'foo']
 
139
        command = ACommand()
142
140
        self.assertEqual(['foo'], command.get_see_also())
143
141
 
144
142
    def test_sorted(self):
145
143
        """_see_also is sorted by get_see_also."""
146
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
144
        class ACommand(commands.Command):
 
145
            _see_also = ['foo', 'bar']
 
146
        command = ACommand()
147
147
        self.assertEqual(['bar', 'foo'], command.get_see_also())
148
148
 
149
149
    def test_additional_terms(self):
150
150
        """Additional terms can be supplied and are deduped and sorted."""
151
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
151
        class ACommand(commands.Command):
 
152
            _see_also = ['foo', 'bar']
 
153
        command = ACommand()
152
154
        self.assertEqual(['bar', 'foo', 'gam'],
153
155
            command.get_see_also(['gam', 'bar', 'gam']))
154
156
 
208
210
        commands.Command.hooks.install_named_hook(
209
211
            "extend_command", hook_calls.append, None)
210
212
        # create a command, should not fire
211
 
        class cmd_test_extend_command_hook(commands.Command):
212
 
            __doc__ = """A sample command."""
 
213
        class ACommand(commands.Command):
 
214
            """A sample command."""
 
215
        cmd = ACommand()
213
216
        self.assertEqual([], hook_calls)
214
217
        # -- as a builtin
215
218
        # register the command class, should not fire
216
219
        try:
217
 
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
 
220
            builtins.cmd_test_extend_command_hook = ACommand
218
221
            self.assertEqual([], hook_calls)
219
222
            # and ask for the object, should fire
220
223
            cmd = commands.get_cmd_object('test-extend-command-hook')
224
227
            self.assertSubset([cmd], hook_calls)
225
228
            del hook_calls[:]
226
229
        finally:
227
 
            commands.builtin_command_registry.remove('test-extend-command-hook')
 
230
            del builtins.cmd_test_extend_command_hook
228
231
        # -- as a plugin lazy registration
229
232
        try:
230
233
            # register the command class, should not fire
246
249
        commands.install_bzr_command_hooks()
247
250
        hook_calls = []
248
251
        class ACommand(commands.Command):
249
 
            __doc__ = """A sample command."""
 
252
            """A sample command."""
250
253
        def get_cmd(cmd_or_None, cmd_name):
251
254
            hook_calls.append(('called', cmd_or_None, cmd_name))
252
255
            if cmd_name in ('foo', 'info'):
273
276
 
274
277
class TestGetMissingCommandHook(tests.TestCase):
275
278
 
276
 
    def hook_missing(self):
277
 
        """Hook get_missing_command for testing."""
278
 
        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 = []
279
283
        class ACommand(commands.Command):
280
 
            __doc__ = """A sample command."""
 
284
            """A sample command."""
281
285
        def get_missing_cmd(cmd_name):
282
 
            self.hook_calls.append(('called', cmd_name))
 
286
            hook_calls.append(('called', cmd_name))
283
287
            if cmd_name in ('foo', 'info'):
284
288
                return ACommand()
285
289
        commands.Command.hooks.install_named_hook(
286
290
            "get_missing_command", get_missing_cmd, None)
287
 
        self.ACommand = ACommand
288
 
 
289
 
    def test_fires_on_get_cmd_object(self):
290
 
        # The get_missing_command(cmd) hook fires when commands are delivered to the
291
 
        # ui.
292
 
        self.hook_missing()
293
291
        # create a command directly, should not fire
294
 
        self.cmd = self.ACommand()
295
 
        self.assertEqual([], self.hook_calls)
 
292
        cmd = ACommand()
 
293
        self.assertEqual([], hook_calls)
296
294
        # ask by name, should fire and give us our command
297
295
        cmd = commands.get_cmd_object('foo')
298
 
        self.assertEqual([('called', 'foo')], self.hook_calls)
299
 
        self.assertIsInstance(cmd, self.ACommand)
300
 
        del self.hook_calls[:]
 
296
        self.assertEqual([('called', 'foo')], hook_calls)
 
297
        self.assertIsInstance(cmd, ACommand)
 
298
        del hook_calls[:]
301
299
        # ask by a name that is supplied by a builtin - the hook should not
302
300
        # fire and we still get our object.
303
301
        commands.install_bzr_command_hooks()
304
302
        cmd = commands.get_cmd_object('info')
305
303
        self.assertNotEqual(None, cmd)
306
 
        self.assertEqual(0, len(self.hook_calls))
307
 
 
308
 
    def test_skipped_on_HelpCommandIndex_get_topics(self):
309
 
        # The get_missing_command(cmd_name) hook is not fired when
310
 
        # looking up help topics.
311
 
        self.hook_missing()
312
 
        topic = commands.HelpCommandIndex()
313
 
        topics = topic.get_topics('foo')
314
 
        self.assertEqual([], self.hook_calls)
 
304
        self.assertEqual(0, len(hook_calls))
315
305
 
316
306
 
317
307
class TestListCommandHook(tests.TestCase):
333
323
        cmds = list(commands.all_command_names())
334
324
        self.assertEqual(['called'], hook_calls)
335
325
        self.assertSubset(['foo', 'bar'], cmds)
336
 
 
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')