/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 bzrlib/tests/test_commands.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

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
12
12
#
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
16
16
 
17
17
from cStringIO import StringIO
18
18
import errno
19
 
import sys
20
19
 
21
20
from bzrlib import (
22
 
    builtins,
23
21
    commands,
24
22
    config,
25
23
    errors,
26
 
    option,
27
 
    symbol_versioning,
28
24
    tests,
29
25
    )
30
26
from bzrlib.commands import display_command
62
58
        self.assertRaises(errors.BzrCommandError,
63
59
                          commands.run_bzr, ['log', u'--option\xb5'])
64
60
 
65
 
    @staticmethod
66
 
    def get_command(options):
67
 
        class cmd_foo(commands.Command):
68
 
            __doc__ = 'Bar'
69
 
 
70
 
            takes_options = options
71
 
 
72
 
        return cmd_foo()
73
 
 
74
 
    def test_help_hidden(self):
75
 
        c = self.get_command([option.Option('foo', hidden=True)])
76
 
        self.assertNotContainsRe(c.get_help_text(), '--foo')
77
 
 
78
 
    def test_help_not_hidden(self):
79
 
        c = self.get_command([option.Option('foo', hidden=False)])
80
 
        self.assertContainsRe(c.get_help_text(), '--foo')
81
 
 
82
61
 
83
62
class TestGetAlias(tests.TestCase):
84
63
 
112
91
 
113
92
    def test_unicode(self):
114
93
        my_config = self._get_config("[ALIASES]\n"
115
 
            u'iam=whoami "Erik B\u00e5gfors <erik@bagfors.nu>"\n')
 
94
            u"iam=whoami 'Erik B\u00e5gfors <erik@bagfors.nu>'\n")
116
95
        self.assertEqual([u'whoami', u'Erik B\u00e5gfors <erik@bagfors.nu>'],
117
96
                          commands.get_alias("iam", config=my_config))
118
97
 
120
99
class TestSeeAlso(tests.TestCase):
121
100
    """Tests for the see also functional of Command."""
122
101
 
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
102
    def test_default_subclass_no_see_also(self):
131
 
        command = self._get_command_with_see_also([])
 
103
        class ACommand(commands.Command):
 
104
            """A sample command."""
 
105
        command = ACommand()
132
106
        self.assertEqual([], command.get_see_also())
133
107
 
134
108
    def test__see_also(self):
135
109
        """When _see_also is defined, it sets the result of get_see_also()."""
136
 
        command = self._get_command_with_see_also(['bar', 'foo'])
 
110
        class ACommand(commands.Command):
 
111
            _see_also = ['bar', 'foo']
 
112
        command = ACommand()
137
113
        self.assertEqual(['bar', 'foo'], command.get_see_also())
138
114
 
139
115
    def test_deduplication(self):
140
116
        """Duplicates in _see_also are stripped out."""
141
 
        command = self._get_command_with_see_also(['foo', 'foo'])
 
117
        class ACommand(commands.Command):
 
118
            _see_also = ['foo', 'foo']
 
119
        command = ACommand()
142
120
        self.assertEqual(['foo'], command.get_see_also())
143
121
 
144
122
    def test_sorted(self):
145
123
        """_see_also is sorted by get_see_also."""
146
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
124
        class ACommand(commands.Command):
 
125
            _see_also = ['foo', 'bar']
 
126
        command = ACommand()
147
127
        self.assertEqual(['bar', 'foo'], command.get_see_also())
148
128
 
149
129
    def test_additional_terms(self):
150
130
        """Additional terms can be supplied and are deduped and sorted."""
151
 
        command = self._get_command_with_see_also(['foo', 'bar'])
 
131
        class ACommand(commands.Command):
 
132
            _see_also = ['foo', 'bar']
 
133
        command = ACommand()
152
134
        self.assertEqual(['bar', 'foo', 'gam'],
153
135
            command.get_see_also(['gam', 'bar', 'gam']))
154
136
 
155
 
 
156
 
class TestRegisterLazy(tests.TestCase):
157
 
 
158
 
    def setUp(self):
159
 
        tests.TestCase.setUp(self)
160
 
        import bzrlib.tests.fake_command
161
 
        del sys.modules['bzrlib.tests.fake_command']
162
 
        global lazy_command_imported
163
 
        lazy_command_imported = False
164
 
        commands.install_bzr_command_hooks()
165
 
 
166
 
    @staticmethod
167
 
    def remove_fake():
168
 
        commands.plugin_cmds.remove('fake')
169
 
 
170
 
    def assertIsFakeCommand(self, cmd_obj):
171
 
        from bzrlib.tests.fake_command import cmd_fake
172
 
        self.assertIsInstance(cmd_obj, cmd_fake)
173
 
 
174
 
    def test_register_lazy(self):
175
 
        """Ensure lazy registration works"""
176
 
        commands.plugin_cmds.register_lazy('cmd_fake', [],
177
 
                                           'bzrlib.tests.fake_command')
178
 
        self.addCleanup(self.remove_fake)
179
 
        self.assertFalse(lazy_command_imported)
180
 
        fake_instance = commands.get_cmd_object('fake')
181
 
        self.assertTrue(lazy_command_imported)
182
 
        self.assertIsFakeCommand(fake_instance)
183
 
 
184
 
    def test_get_unrelated_does_not_import(self):
185
 
        commands.plugin_cmds.register_lazy('cmd_fake', [],
186
 
                                           'bzrlib.tests.fake_command')
187
 
        self.addCleanup(self.remove_fake)
188
 
        commands.get_cmd_object('status')
189
 
        self.assertFalse(lazy_command_imported)
190
 
 
191
 
    def test_aliases(self):
192
 
        commands.plugin_cmds.register_lazy('cmd_fake', ['fake_alias'],
193
 
                                           'bzrlib.tests.fake_command')
194
 
        self.addCleanup(self.remove_fake)
195
 
        fake_instance = commands.get_cmd_object('fake_alias')
196
 
        self.assertIsFakeCommand(fake_instance)
197
 
 
198
 
 
199
 
class TestExtendCommandHook(tests.TestCase):
200
 
 
201
 
    def test_fires_on_get_cmd_object(self):
202
 
        # The extend_command(cmd) hook fires when commands are delivered to the
203
 
        # ui, not simply at registration (because lazy registered plugin
204
 
        # commands are registered).
205
 
        # when they are simply created.
206
 
        hook_calls = []
207
 
        commands.install_bzr_command_hooks()
208
 
        commands.Command.hooks.install_named_hook(
209
 
            "extend_command", hook_calls.append, None)
210
 
        # create a command, should not fire
211
 
        class cmd_test_extend_command_hook(commands.Command):
212
 
            __doc__ = """A sample command."""
213
 
        self.assertEqual([], hook_calls)
214
 
        # -- as a builtin
215
 
        # register the command class, should not fire
216
 
        try:
217
 
            commands.builtin_command_registry.register(cmd_test_extend_command_hook)
218
 
            self.assertEqual([], hook_calls)
219
 
            # and ask for the object, should fire
220
 
            cmd = commands.get_cmd_object('test-extend-command-hook')
221
 
            # For resilience - to ensure all code paths hit it - we
222
 
            # fire on everything returned in the 'cmd_dict', which is currently
223
 
            # all known commands, so assert that cmd is in hook_calls
224
 
            self.assertSubset([cmd], hook_calls)
225
 
            del hook_calls[:]
226
 
        finally:
227
 
            commands.builtin_command_registry.remove('test-extend-command-hook')
228
 
        # -- as a plugin lazy registration
229
 
        try:
230
 
            # register the command class, should not fire
231
 
            commands.plugin_cmds.register_lazy('cmd_fake', [],
232
 
                                               'bzrlib.tests.fake_command')
233
 
            self.assertEqual([], hook_calls)
234
 
            # and ask for the object, should fire
235
 
            cmd = commands.get_cmd_object('fake')
236
 
            self.assertEqual([cmd], hook_calls)
237
 
        finally:
238
 
            commands.plugin_cmds.remove('fake')
239
 
 
240
 
 
241
 
class TestGetCommandHook(tests.TestCase):
242
 
 
243
 
    def test_fires_on_get_cmd_object(self):
244
 
        # The get_command(cmd) hook fires when commands are delivered to the
245
 
        # ui.
246
 
        commands.install_bzr_command_hooks()
247
 
        hook_calls = []
248
 
        class ACommand(commands.Command):
249
 
            __doc__ = """A sample command."""
250
 
        def get_cmd(cmd_or_None, cmd_name):
251
 
            hook_calls.append(('called', cmd_or_None, cmd_name))
252
 
            if cmd_name in ('foo', 'info'):
253
 
                return ACommand()
254
 
        commands.Command.hooks.install_named_hook(
255
 
            "get_command", get_cmd, None)
256
 
        # create a command directly, should not fire
257
 
        cmd = ACommand()
258
 
        self.assertEqual([], hook_calls)
259
 
        # ask by name, should fire and give us our command
260
 
        cmd = commands.get_cmd_object('foo')
261
 
        self.assertEqual([('called', None, 'foo')], hook_calls)
262
 
        self.assertIsInstance(cmd, ACommand)
263
 
        del hook_calls[:]
264
 
        # ask by a name that is supplied by a builtin - the hook should still
265
 
        # fire and we still get our object, but we should see the builtin
266
 
        # passed to the hook.
267
 
        cmd = commands.get_cmd_object('info')
268
 
        self.assertIsInstance(cmd, ACommand)
269
 
        self.assertEqual(1, len(hook_calls))
270
 
        self.assertEqual('info', hook_calls[0][2])
271
 
        self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
272
 
 
273
 
 
274
 
class TestGetMissingCommandHook(tests.TestCase):
275
 
 
276
 
    def hook_missing(self):
277
 
        """Hook get_missing_command for testing."""
278
 
        self.hook_calls = []
279
 
        class ACommand(commands.Command):
280
 
            __doc__ = """A sample command."""
281
 
        def get_missing_cmd(cmd_name):
282
 
            self.hook_calls.append(('called', cmd_name))
283
 
            if cmd_name in ('foo', 'info'):
284
 
                return ACommand()
285
 
        commands.Command.hooks.install_named_hook(
286
 
            "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
 
        # create a command directly, should not fire
294
 
        self.cmd = self.ACommand()
295
 
        self.assertEqual([], self.hook_calls)
296
 
        # ask by name, should fire and give us our command
297
 
        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[:]
301
 
        # ask by a name that is supplied by a builtin - the hook should not
302
 
        # fire and we still get our object.
303
 
        commands.install_bzr_command_hooks()
304
 
        cmd = commands.get_cmd_object('info')
305
 
        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)
315
 
 
316
 
 
317
 
class TestListCommandHook(tests.TestCase):
318
 
 
319
 
    def test_fires_on_all_command_names(self):
320
 
        # The list_commands() hook fires when all_command_names() is invoked.
321
 
        hook_calls = []
322
 
        commands.install_bzr_command_hooks()
323
 
        def list_my_commands(cmd_names):
324
 
            hook_calls.append('called')
325
 
            cmd_names.update(['foo', 'bar'])
326
 
            return cmd_names
327
 
        commands.Command.hooks.install_named_hook(
328
 
            "list_commands", list_my_commands, None)
329
 
        # Get a command, which should not trigger the hook.
330
 
        cmd = commands.get_cmd_object('info')
331
 
        self.assertEqual([], hook_calls)
332
 
        # Get all command classes (for docs and shell completion).
333
 
        cmds = list(commands.all_command_names())
334
 
        self.assertEqual(['called'], hook_calls)
335
 
        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')