← 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: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
from cStringIO import StringIO
18
18
import errno
19
19
import sys
20
20
 
21
21
from bzrlib import (
 
22
    builtins,
22
23
    commands,
23
24
    config,
24
25
    errors,
 
26
    option,
25
27
    tests,
26
28
    )
27
29
from bzrlib.commands import display_command
59
61
        self.assertRaises(errors.BzrCommandError,
60
62
                          commands.run_bzr, ['log', u'--option\xb5'])
61
63
 
 
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
 
62
81
 
63
82
class TestGetAlias(tests.TestCase):
64
83
 
139
158
class TestRegisterLazy(tests.TestCase):
140
159
 
141
160
    def setUp(self):
 
161
        tests.TestCase.setUp(self)
142
162
        import bzrlib.tests.fake_command
143
163
        del sys.modules['bzrlib.tests.fake_command']
144
164
        global lazy_command_imported
145
165
        lazy_command_imported = False
 
166
        commands.install_bzr_command_hooks()
146
167
 
147
168
    @staticmethod
148
169
    def remove_fake():
175
196
        self.addCleanup(self.remove_fake)
176
197
        fake_instance = commands.get_cmd_object('fake_alias')
177
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)