~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_help.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-10 15:58:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4284.
  • Revision ID: jelmer@samba.org-20090410155809-kdibzcjvp7pdb83f
Fix missing import.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007 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
16
16
 
17
17
"""Unit tests for the bzrlib.help module."""
18
18
 
19
 
import textwrap
 
19
from cStringIO import StringIO
20
20
 
21
21
from bzrlib import (
22
22
    builtins,
24
24
    errors,
25
25
    help,
26
26
    help_topics,
27
 
    i18n,
28
27
    plugin,
29
28
    tests,
30
29
    )
31
30
 
32
 
from bzrlib.tests.test_i18n import ZzzTranslations
33
 
import re
34
 
 
35
31
 
36
32
class TestCommandHelp(tests.TestCase):
37
33
    """Tests for help on commands."""
38
34
 
39
 
    def assertCmdHelp(self, expected, cmd):
40
 
        self.assertEqualDiff(textwrap.dedent(expected), cmd.get_help_text())
41
 
 
42
35
    def test_command_help_includes_see_also(self):
43
36
        class cmd_WithSeeAlso(commands.Command):
44
 
            __doc__ = """A sample command."""
 
37
            """A sample command."""
45
38
            _see_also = ['foo', 'bar']
46
 
        self.assertCmdHelp('''\
47
 
            Purpose: A sample command.
48
 
            Usage:   bzr WithSeeAlso
49
 
            
50
 
            Options:
51
 
              --usage        Show usage message and options.
52
 
              -v, --verbose  Display more information.
53
 
              -q, --quiet    Only display errors and warnings.
54
 
              -h, --help     Show help message.
55
 
            
56
 
            See also: bar, foo
57
 
            ''',
58
 
                           cmd_WithSeeAlso())
 
39
        cmd = cmd_WithSeeAlso()
 
40
        helptext = cmd.get_help_text()
 
41
        self.assertEndsWith(
 
42
            helptext,
 
43
            '  -v, --verbose  Display more information.\n'
 
44
            '  -q, --quiet    Only display errors and warnings.\n'
 
45
            '  -h, --help     Show help message.\n'
 
46
            '\n'
 
47
            'See also: bar, foo\n')
59
48
 
60
49
    def test_get_help_text(self):
61
50
        """Commands have a get_help_text method which returns their help."""
62
51
        class cmd_Demo(commands.Command):
63
 
            __doc__ = """A sample command."""
64
 
        self.assertCmdHelp('''\
65
 
            Purpose: A sample command.
66
 
            Usage:   bzr Demo
67
 
            
68
 
            Options:
69
 
              --usage        Show usage message and options.
70
 
              -v, --verbose  Display more information.
71
 
              -q, --quiet    Only display errors and warnings.
72
 
              -h, --help     Show help message.
73
 
 
74
 
            ''',
75
 
                           cmd_Demo())
 
52
            """A sample command."""
76
53
        cmd = cmd_Demo()
77
54
        helptext = cmd.get_help_text()
78
55
        self.assertStartsWith(helptext,
83
60
 
84
61
    def test_command_with_additional_see_also(self):
85
62
        class cmd_WithSeeAlso(commands.Command):
86
 
            __doc__ = """A sample command."""
 
63
            """A sample command."""
87
64
            _see_also = ['foo', 'bar']
88
65
        cmd = cmd_WithSeeAlso()
89
66
        helptext = cmd.get_help_text(['gam'])
97
74
 
98
75
    def test_command_only_additional_see_also(self):
99
76
        class cmd_WithSeeAlso(commands.Command):
100
 
            __doc__ = """A sample command."""
 
77
            """A sample command."""
101
78
        cmd = cmd_WithSeeAlso()
102
79
        helptext = cmd.get_help_text(['gam'])
103
80
        self.assertEndsWith(
111
88
    def test_get_help_topic(self):
112
89
        """The help topic for a Command is its name()."""
113
90
        class cmd_foo_bar(commands.Command):
114
 
            __doc__ = """A sample command."""
 
91
            """A sample command."""
115
92
        cmd = cmd_foo_bar()
116
93
        self.assertEqual(cmd.name(), cmd.get_help_topic())
117
94
 
118
95
    def test_formatted_help_text(self):
119
96
        """Help text should be plain text by default."""
120
97
        class cmd_Demo(commands.Command):
121
 
            __doc__ = """A sample command.
 
98
            """A sample command.
122
99
 
123
100
            :Examples:
124
101
                Example 1::
128
105
                Example 2::
129
106
 
130
107
                    cmd arg2
131
 
 
132
 
                A code block follows.
133
 
 
134
 
                ::
135
 
 
136
 
                    bzr Demo something
137
108
            """
138
109
        cmd = cmd_Demo()
139
110
        helptext = cmd.get_help_text()
156
127
            '    Example 2:\n'
157
128
            '\n'
158
129
            '        cmd arg2\n'
159
 
            '\n'
160
 
            '    A code block follows.\n'
161
 
            '\n'
162
 
            '        bzr Demo something\n'
163
130
            '\n')
164
131
        helptext = cmd.get_help_text(plain=False)
165
132
        self.assertEquals(helptext,
180
147
            '    Example 2::\n'
181
148
            '\n'
182
149
            '        cmd arg2\n'
183
 
            '\n'
184
 
            '    A code block follows.\n'
185
 
            '\n'
186
 
            '    ::\n'
187
 
            '\n'
188
 
            '        bzr Demo something\n'
189
150
            '\n')
190
151
 
191
152
    def test_concise_help_text(self):
192
153
        """Concise help text excludes the descriptive sections."""
193
154
        class cmd_Demo(commands.Command):
194
 
            __doc__ = """A sample command.
 
155
            """A sample command.
195
156
 
196
157
            Blah blah blah.
197
158
 
238
199
    def test_help_custom_section_ordering(self):
239
200
        """Custom descriptive sections should remain in the order given."""
240
201
        class cmd_Demo(commands.Command):
241
 
            __doc__ = """A sample command.
 
202
            """A sample command.
242
203
 
243
204
            Blah blah blah.
244
205
 
284
245
    def test_help_text_custom_usage(self):
285
246
        """Help text may contain a custom usage section."""
286
247
        class cmd_Demo(commands.Command):
287
 
            __doc__ = """A sample command.
 
248
            """A sample command.
288
249
 
289
250
            :Usage:
290
251
                cmd Demo [opts] args
313
274
            '  Blah blah blah.\n\n')
314
275
 
315
276
 
316
 
class ZzzTranslationsForDoc(ZzzTranslations):
317
 
 
318
 
    _section_pat = re.compile(':\w+:\\n\\s+')
319
 
    _indent_pat = re.compile('\\s+')
320
 
 
321
 
    def zzz(self, s):
322
 
        m = self._section_pat.match(s)
323
 
        if m is None:
324
 
            m = self._indent_pat.match(s)
325
 
        if m:
326
 
            return u'%szz{{%s}}' % (m.group(0), s[m.end():])
327
 
        return u'zz{{%s}}' % s
328
 
 
329
 
 
330
 
class TestCommandHelpI18n(tests.TestCase):
331
 
    """Tests for help on translated commands."""
332
 
 
333
 
    def setUp(self):
334
 
        super(TestCommandHelpI18n, self).setUp()
335
 
        self.overrideAttr(i18n, '_translations', ZzzTranslationsForDoc())
336
 
 
337
 
    def assertCmdHelp(self, expected, cmd):
338
 
        self.assertEqualDiff(textwrap.dedent(expected), cmd.get_help_text())
339
 
 
340
 
    def test_command_help_includes_see_also(self):
341
 
        class cmd_WithSeeAlso(commands.Command):
342
 
            __doc__ = """A sample command."""
343
 
            _see_also = ['foo', 'bar']
344
 
        self.assertCmdHelp('''\
345
 
            zz{{:Purpose: zz{{A sample command.}}
346
 
            }}zz{{:Usage:   bzr WithSeeAlso
347
 
            }}
348
 
            zz{{:Options:
349
 
              --usage        Show usage message and options.
350
 
              -v, --verbose  Display more information.
351
 
              -q, --quiet    Only display errors and warnings.
352
 
              -h, --help     Show help message.
353
 
            }}
354
 
            zz{{:See also: bar, foo}}
355
 
            ''',
356
 
                           cmd_WithSeeAlso())
357
 
 
358
 
    def test_get_help_text(self):
359
 
        """Commands have a get_help_text method which returns their help."""
360
 
        class cmd_Demo(commands.Command):
361
 
            __doc__ = """A sample command."""
362
 
        self.assertCmdHelp('''\
363
 
            zz{{:Purpose: zz{{A sample command.}}
364
 
            }}zz{{:Usage:   bzr Demo
365
 
            }}
366
 
            zz{{:Options:
367
 
              --usage        Show usage message and options.
368
 
              -v, --verbose  Display more information.
369
 
              -q, --quiet    Only display errors and warnings.
370
 
              -h, --help     Show help message.
371
 
            }}
372
 
            ''',
373
 
                           cmd_Demo())
374
 
 
375
 
    def test_command_with_additional_see_also(self):
376
 
        class cmd_WithSeeAlso(commands.Command):
377
 
            __doc__ = """A sample command."""
378
 
            _see_also = ['foo', 'bar']
379
 
        cmd = cmd_WithSeeAlso()
380
 
        helptext = cmd.get_help_text(['gam'])
381
 
        self.assertEndsWith(
382
 
            helptext,
383
 
            '  -v, --verbose  Display more information.\n'
384
 
            '  -q, --quiet    Only display errors and warnings.\n'
385
 
            '  -h, --help     Show help message.\n'
386
 
            '}}\n'
387
 
            'zz{{:See also: bar, foo, gam}}\n')
388
 
 
389
 
    def test_command_only_additional_see_also(self):
390
 
        class cmd_WithSeeAlso(commands.Command):
391
 
            __doc__ = """A sample command."""
392
 
        cmd = cmd_WithSeeAlso()
393
 
        helptext = cmd.get_help_text(['gam'])
394
 
        self.assertEndsWith(
395
 
            helptext,
396
 
            'zz{{:Options:\n'
397
 
            '  --usage        Show usage message and options.\n'
398
 
            '  -v, --verbose  Display more information.\n'
399
 
            '  -q, --quiet    Only display errors and warnings.\n'
400
 
            '  -h, --help     Show help message.\n'
401
 
            '}}\n'
402
 
            'zz{{:See also: gam}}\n')
403
 
 
404
 
 
405
 
    def test_help_custom_section_ordering(self):
406
 
        """Custom descriptive sections should remain in the order given."""
407
 
        # The help formatter expect the class name to start with 'cmd_'
408
 
        class cmd_Demo(commands.Command):
409
 
            __doc__ = """A sample command.
410
 
 
411
 
            Blah blah blah.
412
 
 
413
 
            :Formats:
414
 
              Interesting stuff about formats.
415
 
 
416
 
            :Examples:
417
 
              Example 1::
418
 
 
419
 
                cmd arg1
420
 
 
421
 
            :Tips:
422
 
              Clever things to keep in mind.
423
 
            """
424
 
        self.assertCmdHelp('''\
425
 
            zz{{:Purpose: zz{{A sample command.}}
426
 
            }}zz{{:Usage:   bzr Demo
427
 
            }}
428
 
            zz{{:Options:
429
 
              --usage        Show usage message and options.
430
 
              -v, --verbose  Display more information.
431
 
              -q, --quiet    Only display errors and warnings.
432
 
              -h, --help     Show help message.
433
 
            }}
434
 
            Description:
435
 
              zz{{zz{{Blah blah blah.}}
436
 
            
437
 
            }}:Formats:
438
 
              zz{{Interesting stuff about formats.}}
439
 
            
440
 
            Examples:
441
 
              zz{{Example 1::}}
442
 
            
443
 
                zz{{cmd arg1}}
444
 
            
445
 
            Tips:
446
 
              zz{{Clever things to keep in mind.}}
447
 
 
448
 
            ''',
449
 
                           cmd_Demo())
450
 
 
451
 
    def test_help_text_custom_usage(self):
452
 
        """Help text may contain a custom usage section."""
453
 
        class cmd_Demo(commands.Command):
454
 
            __doc__ = """A sample command.
455
 
 
456
 
            :Usage:
457
 
                cmd Demo [opts] args
458
 
 
459
 
                cmd Demo -h
460
 
 
461
 
            Blah blah blah.
462
 
            """
463
 
        self.assertCmdHelp('''\
464
 
            zz{{:Purpose: zz{{A sample command.}}
465
 
            }}zz{{:Usage:
466
 
                zz{{cmd Demo [opts] args}}
467
 
            
468
 
                zz{{cmd Demo -h}}
469
 
 
470
 
            }}
471
 
            zz{{:Options:
472
 
              --usage        Show usage message and options.
473
 
              -v, --verbose  Display more information.
474
 
              -q, --quiet    Only display errors and warnings.
475
 
              -h, --help     Show help message.
476
 
            }}
477
 
            Description:
478
 
              zz{{zz{{Blah blah blah.}}
479
 
 
480
 
            }}
481
 
            ''',
482
 
                           cmd_Demo())
483
 
 
484
 
 
485
 
class TestHelp(tests.TestCase):
486
 
 
487
 
    def setUp(self):
488
 
        tests.TestCase.setUp(self)
489
 
        commands.install_bzr_command_hooks()
490
 
 
491
 
 
492
 
class TestRegisteredTopic(TestHelp):
 
277
class TestRegisteredTopic(tests.TestCase):
493
278
    """Tests for the RegisteredTopic class."""
494
279
 
495
280
    def test_contruct(self):
500
285
        self.assertEqual('basic', topic.topic)
501
286
 
502
287
    def test_get_help_text(self):
503
 
        """RegisteredTopic returns the get_detail results for get_help_text."""
 
288
        """A RegisteredTopic returns the get_detail results for get_help_text."""
504
289
        topic = help_topics.RegisteredTopic('commands')
505
290
        self.assertEqual(help_topics.topic_registry.get_detail('commands'),
506
 
                         topic.get_help_text())
 
291
            topic.get_help_text())
507
292
 
508
293
    def test_get_help_text_with_additional_see_also(self):
509
294
        topic = help_topics.RegisteredTopic('commands')
521
306
            '\n')
522
307
 
523
308
    def test_get_help_topic(self):
524
 
        """The help topic for RegisteredTopic is its topic from construction."""
 
309
        """The help topic for a RegisteredTopic is its topic from construction."""
525
310
        topic = help_topics.RegisteredTopic('foobar')
526
311
        self.assertEqual('foobar', topic.get_help_topic())
527
312
        topic = help_topics.RegisteredTopic('baz')
528
313
        self.assertEqual('baz', topic.get_help_topic())
529
314
 
530
315
 
531
 
class TestTopicIndex(TestHelp):
 
316
class TestTopicIndex(tests.TestCase):
532
317
    """Tests for the HelpTopicIndex class."""
533
318
 
534
319
    def test_default_constructable(self):
561
346
        self.assertEqual('', index.prefix)
562
347
 
563
348
 
564
 
class TestCommandIndex(TestHelp):
 
349
class TestCommandIndex(tests.TestCase):
565
350
    """Tests for the HelpCommandIndex class."""
566
351
 
567
352
    def test_default_constructable(self):