← 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: 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
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
24
    tests,
28
25
    )
29
26
from bzrlib.commands import display_command
61
58
        self.assertRaises(errors.BzrCommandError,
62
59
                          commands.run_bzr, ['log', u'--option\xb5'])
63
60
 
64
 
    @staticmethod
65
 
    def get_command(options):
66
 
        class cmd_foo(commands.Command):
67
 
            'Bar'
68
 
 
69
 
            takes_options = options
70
 
 
71
 
        return cmd_foo()
72
 
 
73
 
    def test_help_hidden(self):
74
 
        c = self.get_command([option.Option('foo', hidden=True)])
75
 
        self.assertNotContainsRe(c.get_help_text(), '--foo')
76
 
 
77
 
    def test_help_not_hidden(self):
78
 
        c = self.get_command([option.Option('foo', hidden=False)])
79
 
        self.assertContainsRe(c.get_help_text(), '--foo')
80
 
 
81
61
 
82
62
class TestGetAlias(tests.TestCase):
83
63
 
154
134
        self.assertEqual(['bar', 'foo', 'gam'],
155
135
            command.get_see_also(['gam', 'bar', 'gam']))
156
136
 
157
 
 
158
 
class TestRegisterLazy(tests.TestCase):
159
 
 
160
 
    def setUp(self):
161
 
        tests.TestCase.setUp(self)
162
 
        import bzrlib.tests.fake_command
163
 
        del sys.modules['bzrlib.tests.fake_command']
164
 
        global lazy_command_imported
165
 
        lazy_command_imported = False
166
 
        commands.install_bzr_command_hooks()
167
 
 
168
 
    @staticmethod
169
 
    def remove_fake():
170
 
        commands.plugin_cmds.remove('fake')
171
 
 
172
 
    def assertIsFakeCommand(self, cmd_obj):
173
 
        from bzrlib.tests.fake_command import cmd_fake
174
 
        self.assertIsInstance(cmd_obj, cmd_fake)
175
 
 
176
 
    def test_register_lazy(self):
177
 
        """Ensure lazy registration works"""
178
 
        commands.plugin_cmds.register_lazy('cmd_fake', [],
179
 
                                           'bzrlib.tests.fake_command')
180
 
        self.addCleanup(self.remove_fake)
181
 
        self.assertFalse(lazy_command_imported)
182
 
        fake_instance = commands.get_cmd_object('fake')
183
 
        self.assertTrue(lazy_command_imported)
184
 
        self.assertIsFakeCommand(fake_instance)
185
 
 
186
 
    def test_get_unrelated_does_not_import(self):
187
 
        commands.plugin_cmds.register_lazy('cmd_fake', [],
188
 
                                           'bzrlib.tests.fake_command')
189
 
        self.addCleanup(self.remove_fake)
190
 
        commands.get_cmd_object('status')
191
 
        self.assertFalse(lazy_command_imported)
192
 
 
193
 
    def test_aliases(self):
194
 
        commands.plugin_cmds.register_lazy('cmd_fake', ['fake_alias'],
195
 
                                           'bzrlib.tests.fake_command')
196
 
        self.addCleanup(self.remove_fake)
197
 
        fake_instance = commands.get_cmd_object('fake_alias')
198
 
        self.assertIsFakeCommand(fake_instance)
199
 
 
200
 
 
201
 
class TestExtendCommandHook(tests.TestCase):
202
 
 
203
 
    def test_fires_on_get_cmd_object(self):
204
 
        # The extend_command(cmd) hook fires when commands are delivered to the
205
 
        # ui, not simply at registration (because lazy registered plugin
206
 
        # commands are registered).
207
 
        # when they are simply created.
208
 
        hook_calls = []
209
 
        commands.install_bzr_command_hooks()
210
 
        commands.Command.hooks.install_named_hook(
211
 
            "extend_command", hook_calls.append, None)
212
 
        # create a command, should not fire
213
 
        class ACommand(commands.Command):
214
 
            """A sample command."""
215
 
        cmd = ACommand()
216
 
        self.assertEqual([], hook_calls)
217
 
        # -- as a builtin
218
 
        # register the command class, should not fire
219
 
        try:
220
 
            builtins.cmd_test_extend_command_hook = ACommand
221
 
            self.assertEqual([], hook_calls)
222
 
            # and ask for the object, should fire
223
 
            cmd = commands.get_cmd_object('test-extend-command-hook')
224
 
            # For resilience - to ensure all code paths hit it - we
225
 
            # fire on everything returned in the 'cmd_dict', which is currently
226
 
            # all known commands, so assert that cmd is in hook_calls
227
 
            self.assertSubset([cmd], hook_calls)
228
 
            del hook_calls[:]
229
 
        finally:
230
 
            del builtins.cmd_test_extend_command_hook
231
 
        # -- as a plugin lazy registration
232
 
        try:
233
 
            # register the command class, should not fire
234
 
            commands.plugin_cmds.register_lazy('cmd_fake', [],
235
 
                                               'bzrlib.tests.fake_command')
236
 
            self.assertEqual([], hook_calls)
237
 
            # and ask for the object, should fire
238
 
            cmd = commands.get_cmd_object('fake')
239
 
            self.assertEqual([cmd], hook_calls)
240
 
        finally:
241
 
            commands.plugin_cmds.remove('fake')
242
 
 
243
 
 
244
 
class TestGetCommandHook(tests.TestCase):
245
 
 
246
 
    def test_fires_on_get_cmd_object(self):
247
 
        # The get_command(cmd) hook fires when commands are delivered to the
248
 
        # ui.
249
 
        commands.install_bzr_command_hooks()
250
 
        hook_calls = []
251
 
        class ACommand(commands.Command):
252
 
            """A sample command."""
253
 
        def get_cmd(cmd_or_None, cmd_name):
254
 
            hook_calls.append(('called', cmd_or_None, cmd_name))
255
 
            if cmd_name in ('foo', 'info'):
256
 
                return ACommand()
257
 
        commands.Command.hooks.install_named_hook(
258
 
            "get_command", get_cmd, None)
259
 
        # create a command directly, should not fire
260
 
        cmd = ACommand()
261
 
        self.assertEqual([], hook_calls)
262
 
        # ask by name, should fire and give us our command
263
 
        cmd = commands.get_cmd_object('foo')
264
 
        self.assertEqual([('called', None, 'foo')], hook_calls)
265
 
        self.assertIsInstance(cmd, ACommand)
266
 
        del hook_calls[:]
267
 
        # ask by a name that is supplied by a builtin - the hook should still
268
 
        # fire and we still get our object, but we should see the builtin
269
 
        # passed to the hook.
270
 
        cmd = commands.get_cmd_object('info')
271
 
        self.assertIsInstance(cmd, ACommand)
272
 
        self.assertEqual(1, len(hook_calls))
273
 
        self.assertEqual('info', hook_calls[0][2])
274
 
        self.assertIsInstance(hook_calls[0][1], builtins.cmd_info)
275
 
 
276
 
 
277
 
class TestGetMissingCommandHook(tests.TestCase):
278
 
 
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 = []
283
 
        class ACommand(commands.Command):
284
 
            """A sample command."""
285
 
        def get_missing_cmd(cmd_name):
286
 
            hook_calls.append(('called', cmd_name))
287
 
            if cmd_name in ('foo', 'info'):
288
 
                return ACommand()
289
 
        commands.Command.hooks.install_named_hook(
290
 
            "get_missing_command", get_missing_cmd, None)
291
 
        # create a command directly, should not fire
292
 
        cmd = ACommand()
293
 
        self.assertEqual([], hook_calls)
294
 
        # ask by name, should fire and give us our command
295
 
        cmd = commands.get_cmd_object('foo')
296
 
        self.assertEqual([('called', 'foo')], hook_calls)
297
 
        self.assertIsInstance(cmd, ACommand)
298
 
        del hook_calls[:]
299
 
        # ask by a name that is supplied by a builtin - the hook should not
300
 
        # fire and we still get our object.
301
 
        commands.install_bzr_command_hooks()
302
 
        cmd = commands.get_cmd_object('info')
303
 
        self.assertNotEqual(None, cmd)
304
 
        self.assertEqual(0, len(hook_calls))
305
 
 
306
 
 
307
 
class TestListCommandHook(tests.TestCase):
308
 
 
309
 
    def test_fires_on_all_command_names(self):
310
 
        # The list_commands() hook fires when all_command_names() is invoked.
311
 
        hook_calls = []
312
 
        commands.install_bzr_command_hooks()
313
 
        def list_my_commands(cmd_names):
314
 
            hook_calls.append('called')
315
 
            cmd_names.update(['foo', 'bar'])
316
 
            return cmd_names
317
 
        commands.Command.hooks.install_named_hook(
318
 
            "list_commands", list_my_commands, None)
319
 
        # Get a command, which should not trigger the hook.
320
 
        cmd = commands.get_cmd_object('info')
321
 
        self.assertEqual([], hook_calls)
322
 
        # Get all command classes (for docs and shell completion).
323
 
        cmds = list(commands.all_command_names())
324
 
        self.assertEqual(['called'], hook_calls)
325
 
        self.assertSubset(['foo', 'bar'], cmds)