← 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: 2009-06-15 12:03:59 UTC
  • mfrom: (4119.3.16 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090615120359-3a9650kr76j1jyf2
(robertc) Make core command lookup fully hookable and extensible.
        (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_commands.py
163
163
        del sys.modules['bzrlib.tests.fake_command']
164
164
        global lazy_command_imported
165
165
        lazy_command_imported = False
 
166
        commands.install_bzr_command_hooks()
166
167
 
167
168
    @staticmethod
168
169
    def remove_fake():
205
206
        # commands are registered).
206
207
        # when they are simply created.
207
208
        hook_calls = []
 
209
        commands.install_bzr_command_hooks()
208
210
        commands.Command.hooks.install_named_hook(
209
211
            "extend_command", hook_calls.append, None)
210
212
        # create a command, should not fire
237
239
            self.assertEqual([cmd], hook_calls)
238
240
        finally:
239
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)