← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_help.py

  • Committer: Vincent Ladeuil
  • Date: 2010-03-10 09:33:04 UTC
  • mto: (5082.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5083.
  • Revision ID: v.ladeuil+lp@free.fr-20100310093304-4245t4tazd4sxoav
Cleanup test from overly cautious checks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_help.py
1
 
# Copyright (C) 2007-2012, 2016 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,
23
23
    commands,
24
 
    config,
25
24
    errors,
26
25
    help,
27
26
    help_topics,
28
 
    i18n,
29
27
    plugin,
30
28
    tests,
31
29
    )
32
30
 
33
 
from bzrlib.tests.test_i18n import ZzzTranslations
34
 
import re
 
31
 
 
32
class TestHelp(tests.TestCase):
 
33
 
 
34
    def setUp(self):
 
35
        tests.TestCase.setUp(self)
 
36
        commands.install_bzr_command_hooks()
35
37
 
36
38
 
37
39
class TestCommandHelp(tests.TestCase):
38
40
    """Tests for help on commands."""
39
41
 
40
 
    def assertCmdHelp(self, expected, cmd):
41
 
        self.assertEqualDiff(textwrap.dedent(expected), cmd.get_help_text())
42
 
 
43
42
    def test_command_help_includes_see_also(self):
44
43
        class cmd_WithSeeAlso(commands.Command):
45
 
            __doc__ = """A sample command."""
 
44
            """A sample command."""
46
45
            _see_also = ['foo', 'bar']
47
 
        self.assertCmdHelp('''\
48
 
Purpose: A sample command.
49
 
Usage:   bzr WithSeeAlso
50
 
 
51
 
Options:
52
 
  --usage        Show usage message and options.
53
 
  -q, --quiet    Only display errors and warnings.
54
 
  -v, --verbose  Display more information.
55
 
  -h, --help     Show help message.
56
 
 
57
 
See also: bar, foo
58
 
''',
59
 
                           cmd_WithSeeAlso())
 
46
        cmd = cmd_WithSeeAlso()
 
47
        helptext = cmd.get_help_text()
 
48
        self.assertEndsWith(
 
49
            helptext,
 
50
            '  -v, --verbose  Display more information.\n'
 
51
            '  -q, --quiet    Only display errors and warnings.\n'
 
52
            '  -h, --help     Show help message.\n'
 
53
            '\n'
 
54
            'See also: bar, foo\n')
60
55
 
61
56
    def test_get_help_text(self):
62
57
        """Commands have a get_help_text method which returns their help."""
63
58
        class cmd_Demo(commands.Command):
64
 
            __doc__ = """A sample command."""
65
 
        self.assertCmdHelp('''\
66
 
Purpose: A sample command.
67
 
Usage:   bzr Demo
68
 
 
69
 
Options:
70
 
  --usage        Show usage message and options.
71
 
  -q, --quiet    Only display errors and warnings.
72
 
  -v, --verbose  Display more information.
73
 
  -h, --help     Show help message.
74
 
 
75
 
''',
76
 
                           cmd_Demo())
 
59
            """A sample command."""
77
60
        cmd = cmd_Demo()
78
61
        helptext = cmd.get_help_text()
79
62
        self.assertStartsWith(helptext,
84
67
 
85
68
    def test_command_with_additional_see_also(self):
86
69
        class cmd_WithSeeAlso(commands.Command):
87
 
            __doc__ = """A sample command."""
 
70
            """A sample command."""
88
71
            _see_also = ['foo', 'bar']
89
72
        cmd = cmd_WithSeeAlso()
90
73
        helptext = cmd.get_help_text(['gam'])
91
74
        self.assertEndsWith(
92
75
            helptext,
 
76
            '  -v, --verbose  Display more information.\n'
93
77
            '  -q, --quiet    Only display errors and warnings.\n'
94
 
            '  -v, --verbose  Display more information.\n'
95
78
            '  -h, --help     Show help message.\n'
96
79
            '\n'
97
80
            'See also: bar, foo, gam\n')
98
81
 
99
82
    def test_command_only_additional_see_also(self):
100
83
        class cmd_WithSeeAlso(commands.Command):
101
 
            __doc__ = """A sample command."""
 
84
            """A sample command."""
102
85
        cmd = cmd_WithSeeAlso()
103
86
        helptext = cmd.get_help_text(['gam'])
104
87
        self.assertEndsWith(
105
88
            helptext,
 
89
            '  -v, --verbose  Display more information.\n'
106
90
            '  -q, --quiet    Only display errors and warnings.\n'
107
 
            '  -v, --verbose  Display more information.\n'
108
91
            '  -h, --help     Show help message.\n'
109
92
            '\n'
110
93
            'See also: gam\n')
112
95
    def test_get_help_topic(self):
113
96
        """The help topic for a Command is its name()."""
114
97
        class cmd_foo_bar(commands.Command):
115
 
            __doc__ = """A sample command."""
 
98
            """A sample command."""
116
99
        cmd = cmd_foo_bar()
117
100
        self.assertEqual(cmd.name(), cmd.get_help_topic())
118
101
 
119
102
    def test_formatted_help_text(self):
120
103
        """Help text should be plain text by default."""
121
104
        class cmd_Demo(commands.Command):
122
 
            __doc__ = """A sample command.
 
105
            """A sample command.
123
106
 
124
107
            :Examples:
125
108
                Example 1::
129
112
                Example 2::
130
113
 
131
114
                    cmd arg2
132
 
 
133
 
                A code block follows.
134
 
 
135
 
                ::
136
 
 
137
 
                    bzr Demo something
138
115
            """
139
116
        cmd = cmd_Demo()
140
117
        helptext = cmd.get_help_text()
141
 
        self.assertEqualDiff('''\
142
 
Purpose: A sample command.
143
 
Usage:   bzr Demo
144
 
 
145
 
Options:
146
 
  --usage        Show usage message and options.
147
 
  -q, --quiet    Only display errors and warnings.
148
 
  -v, --verbose  Display more information.
149
 
  -h, --help     Show help message.
150
 
 
151
 
Examples:
152
 
    Example 1:
153
 
 
154
 
        cmd arg1
155
 
 
156
 
    Example 2:
157
 
 
158
 
        cmd arg2
159
 
 
160
 
    A code block follows.
161
 
 
162
 
        bzr Demo something
163
 
 
164
 
''',
165
 
                                         helptext)
 
118
        self.assertEquals(
 
119
            helptext,
 
120
            'Purpose: A sample command.\n'
 
121
            'Usage:   bzr Demo\n'
 
122
            '\n'
 
123
            'Options:\n'
 
124
            '  --usage        Show usage message and options.\n'
 
125
            '  -v, --verbose  Display more information.\n'
 
126
            '  -q, --quiet    Only display errors and warnings.\n'
 
127
            '  -h, --help     Show help message.\n'
 
128
            '\n'
 
129
            'Examples:\n'
 
130
            '    Example 1:\n'
 
131
            '\n'
 
132
            '        cmd arg1\n'
 
133
            '\n'
 
134
            '    Example 2:\n'
 
135
            '\n'
 
136
            '        cmd arg2\n'
 
137
            '\n')
166
138
        helptext = cmd.get_help_text(plain=False)
167
 
        self.assertEqualDiff('''\
168
 
:Purpose: A sample command.
169
 
:Usage:   bzr Demo
170
 
 
171
 
:Options:
172
 
  --usage        Show usage message and options.
173
 
  -q, --quiet    Only display errors and warnings.
174
 
  -v, --verbose  Display more information.
175
 
  -h, --help     Show help message.
176
 
 
177
 
:Examples:
178
 
    Example 1::
179
 
 
180
 
        cmd arg1
181
 
 
182
 
    Example 2::
183
 
 
184
 
        cmd arg2
185
 
 
186
 
    A code block follows.
187
 
 
188
 
    ::
189
 
 
190
 
        bzr Demo something
191
 
 
192
 
''',
193
 
                             helptext)
 
139
        self.assertEquals(helptext,
 
140
            ':Purpose: A sample command.\n'
 
141
            ':Usage:   bzr Demo\n'
 
142
            '\n'
 
143
            ':Options:\n'
 
144
            '  --usage        Show usage message and options.\n'
 
145
            '  -v, --verbose  Display more information.\n'
 
146
            '  -q, --quiet    Only display errors and warnings.\n'
 
147
            '  -h, --help     Show help message.\n'
 
148
            '\n'
 
149
            ':Examples:\n'
 
150
            '    Example 1::\n'
 
151
            '\n'
 
152
            '        cmd arg1\n'
 
153
            '\n'
 
154
            '    Example 2::\n'
 
155
            '\n'
 
156
            '        cmd arg2\n'
 
157
            '\n')
194
158
 
195
159
    def test_concise_help_text(self):
196
160
        """Concise help text excludes the descriptive sections."""
197
161
        class cmd_Demo(commands.Command):
198
 
            __doc__ = """A sample command.
 
162
            """A sample command.
199
163
 
200
164
            Blah blah blah.
201
165
 
206
170
            """
207
171
        cmd = cmd_Demo()
208
172
        helptext = cmd.get_help_text()
209
 
        self.assertEqualDiff('''\
210
 
Purpose: A sample command.
211
 
Usage:   bzr Demo
212
 
 
213
 
Options:
214
 
  --usage        Show usage message and options.
215
 
  -q, --quiet    Only display errors and warnings.
216
 
  -v, --verbose  Display more information.
217
 
  -h, --help     Show help message.
218
 
 
219
 
Description:
220
 
  Blah blah blah.
221
 
 
222
 
Examples:
223
 
    Example 1:
224
 
 
225
 
        cmd arg1
226
 
 
227
 
''',
228
 
                             helptext)
 
173
        self.assertEqualDiff(
 
174
            helptext,
 
175
            'Purpose: A sample command.\n'
 
176
            'Usage:   bzr Demo\n'
 
177
            '\n'
 
178
            'Options:\n'
 
179
            '  --usage        Show usage message and options.\n'
 
180
            '  -v, --verbose  Display more information.\n'
 
181
            '  -q, --quiet    Only display errors and warnings.\n'
 
182
            '  -h, --help     Show help message.\n'
 
183
            '\n'
 
184
            'Description:\n'
 
185
            '  Blah blah blah.\n'
 
186
            '\n'
 
187
            'Examples:\n'
 
188
            '    Example 1:\n'
 
189
            '\n'
 
190
            '        cmd arg1\n'
 
191
            '\n')
229
192
        helptext = cmd.get_help_text(verbose=False)
230
 
        self.assertEqualDiff('''\
231
 
Purpose: A sample command.
232
 
Usage:   bzr Demo
233
 
 
234
 
Options:
235
 
  --usage        Show usage message and options.
236
 
  -q, --quiet    Only display errors and warnings.
237
 
  -v, --verbose  Display more information.
238
 
  -h, --help     Show help message.
239
 
 
240
 
See bzr help Demo for more details and examples.
241
 
 
242
 
''',
243
 
                             helptext)
244
 
 
245
 
    def test_help_custom_section_ordering(self):
246
 
        """Custom descriptive sections should remain in the order given."""
247
 
        class cmd_Demo(commands.Command):
248
 
            __doc__ = """\
249
 
A sample command.
250
 
 
251
 
Blah blah blah.
252
 
 
253
 
:Formats:
254
 
  Interesting stuff about formats.
255
 
 
256
 
:Examples:
257
 
  Example 1::
258
 
 
259
 
    cmd arg1
260
 
 
261
 
:Tips:
262
 
  Clever things to keep in mind.
263
 
"""
264
 
        cmd = cmd_Demo()
265
 
        helptext = cmd.get_help_text()
266
 
        self.assertEqualDiff('''\
267
 
Purpose: A sample command.
268
 
Usage:   bzr Demo
269
 
 
270
 
Options:
271
 
  --usage        Show usage message and options.
272
 
  -q, --quiet    Only display errors and warnings.
273
 
  -v, --verbose  Display more information.
274
 
  -h, --help     Show help message.
275
 
 
276
 
Description:
277
 
  Blah blah blah.
278
 
 
279
 
Formats:
280
 
  Interesting stuff about formats.
281
 
 
282
 
Examples:
283
 
  Example 1:
284
 
 
285
 
    cmd arg1
286
 
 
287
 
Tips:
288
 
  Clever things to keep in mind.
289
 
 
290
 
''',
291
 
                             helptext)
292
 
 
293
 
    def test_help_text_custom_usage(self):
294
 
        """Help text may contain a custom usage section."""
295
 
        class cmd_Demo(commands.Command):
296
 
            __doc__ = """A sample command.
297
 
 
298
 
            :Usage:
299
 
                cmd Demo [opts] args
300
 
 
301
 
                cmd Demo -h
302
 
 
303
 
            Blah blah blah.
304
 
            """
305
 
        cmd = cmd_Demo()
306
 
        helptext = cmd.get_help_text()
307
 
        self.assertEqualDiff('''\
308
 
Purpose: A sample command.
309
 
Usage:
310
 
    cmd Demo [opts] args
311
 
 
312
 
    cmd Demo -h
313
 
 
314
 
 
315
 
Options:
316
 
  --usage        Show usage message and options.
317
 
  -q, --quiet    Only display errors and warnings.
318
 
  -v, --verbose  Display more information.
319
 
  -h, --help     Show help message.
320
 
 
321
 
Description:
322
 
  Blah blah blah.
323
 
 
324
 
''',
325
 
                             helptext)
326
 
 
327
 
 
328
 
class ZzzTranslationsForDoc(ZzzTranslations):
329
 
 
330
 
    _section_pat = re.compile(':\w+:\\n\\s+')
331
 
    _indent_pat = re.compile('\\s+')
332
 
 
333
 
    def zzz(self, s):
334
 
        m = self._section_pat.match(s)
335
 
        if m is None:
336
 
            m = self._indent_pat.match(s)
337
 
        if m:
338
 
            return u'%szz{{%s}}' % (m.group(0), s[m.end():])
339
 
        return u'zz{{%s}}' % s
340
 
 
341
 
 
342
 
class TestCommandHelpI18n(tests.TestCase):
343
 
    """Tests for help on translated commands."""
344
 
 
345
 
    def setUp(self):
346
 
        super(TestCommandHelpI18n, self).setUp()
347
 
        self.overrideAttr(i18n, '_translations', ZzzTranslationsForDoc())
348
 
 
349
 
    def assertCmdHelp(self, expected, cmd):
350
 
        self.assertEqualDiff(textwrap.dedent(expected), cmd.get_help_text())
351
 
 
352
 
    def test_command_help_includes_see_also(self):
353
 
        class cmd_WithSeeAlso(commands.Command):
354
 
            __doc__ = """A sample command."""
355
 
            _see_also = ['foo', 'bar']
356
 
        self.assertCmdHelp('''\
357
 
zz{{:Purpose: zz{{A sample command.}}
358
 
}}zz{{:Usage:   bzr WithSeeAlso
359
 
}}
360
 
zz{{:Options:
361
 
  --usage        zz{{Show usage message and options.}}
362
 
  -q, --quiet    zz{{Only display errors and warnings.}}
363
 
  -v, --verbose  zz{{Display more information.}}
364
 
  -h, --help     zz{{Show help message.}}
365
 
}}
366
 
zz{{:See also: bar, foo}}
367
 
''',
368
 
                           cmd_WithSeeAlso())
369
 
 
370
 
    def test_get_help_text(self):
371
 
        """Commands have a get_help_text method which returns their help."""
372
 
        class cmd_Demo(commands.Command):
373
 
            __doc__ = """A sample command."""
374
 
        self.assertCmdHelp('''\
375
 
zz{{:Purpose: zz{{A sample command.}}
376
 
}}zz{{:Usage:   bzr Demo
377
 
}}
378
 
zz{{:Options:
379
 
  --usage        zz{{Show usage message and options.}}
380
 
  -q, --quiet    zz{{Only display errors and warnings.}}
381
 
  -v, --verbose  zz{{Display more information.}}
382
 
  -h, --help     zz{{Show help message.}}
383
 
}}
384
 
''',
385
 
                           cmd_Demo())
386
 
 
387
 
    def test_command_with_additional_see_also(self):
388
 
        class cmd_WithSeeAlso(commands.Command):
389
 
            __doc__ = """A sample command."""
390
 
            _see_also = ['foo', 'bar']
391
 
        cmd = cmd_WithSeeAlso()
392
 
        helptext = cmd.get_help_text(['gam'])
393
 
        self.assertEndsWith(
394
 
            helptext,'''\
395
 
  -q, --quiet    zz{{Only display errors and warnings.}}
396
 
  -v, --verbose  zz{{Display more information.}}
397
 
  -h, --help     zz{{Show help message.}}
398
 
}}
399
 
zz{{:See also: bar, foo, gam}}
400
 
''')
401
 
 
402
 
    def test_command_only_additional_see_also(self):
403
 
        class cmd_WithSeeAlso(commands.Command):
404
 
            __doc__ = """A sample command."""
405
 
        cmd = cmd_WithSeeAlso()
406
 
        helptext = cmd.get_help_text(['gam'])
407
 
        self.assertEndsWith(
408
 
            helptext, '''\
409
 
zz{{:Options:
410
 
  --usage        zz{{Show usage message and options.}}
411
 
  -q, --quiet    zz{{Only display errors and warnings.}}
412
 
  -v, --verbose  zz{{Display more information.}}
413
 
  -h, --help     zz{{Show help message.}}
414
 
}}
415
 
zz{{:See also: gam}}
416
 
''')
417
 
 
418
 
 
419
 
    def test_help_custom_section_ordering(self):
420
 
        """Custom descriptive sections should remain in the order given."""
421
 
        # The help formatter expect the class name to start with 'cmd_'
422
 
        class cmd_Demo(commands.Command):
423
 
            __doc__ = """A sample command.
 
193
        self.assertEquals(helptext,
 
194
            'Purpose: A sample command.\n'
 
195
            'Usage:   bzr Demo\n'
 
196
            '\n'
 
197
            'Options:\n'
 
198
            '  --usage        Show usage message and options.\n'
 
199
            '  -v, --verbose  Display more information.\n'
 
200
            '  -q, --quiet    Only display errors and warnings.\n'
 
201
            '  -h, --help     Show help message.\n'
 
202
            '\n'
 
203
            'See bzr help Demo for more details and examples.\n'
 
204
            '\n')
 
205
 
 
206
    def test_help_custom_section_ordering(self):
 
207
        """Custom descriptive sections should remain in the order given."""
 
208
        class cmd_Demo(commands.Command):
 
209
            """A sample command.
424
210
 
425
211
            Blah blah blah.
426
212
 
435
221
            :Tips:
436
222
              Clever things to keep in mind.
437
223
            """
438
 
        self.assertCmdHelp('''\
439
 
zz{{:Purpose: zz{{A sample command.}}
440
 
}}zz{{:Usage:   bzr Demo
441
 
}}
442
 
zz{{:Options:
443
 
  --usage        zz{{Show usage message and options.}}
444
 
  -q, --quiet    zz{{Only display errors and warnings.}}
445
 
  -v, --verbose  zz{{Display more information.}}
446
 
  -h, --help     zz{{Show help message.}}
447
 
}}
448
 
Description:
449
 
  zz{{zz{{Blah blah blah.}}
450
 
 
451
 
}}:Formats:
452
 
  zz{{Interesting stuff about formats.}}
453
 
 
454
 
Examples:
455
 
  zz{{Example 1::}}
456
 
 
457
 
    zz{{cmd arg1}}
458
 
 
459
 
Tips:
460
 
  zz{{Clever things to keep in mind.}}
461
 
 
462
 
''',
463
 
                           cmd_Demo())
 
224
        cmd = cmd_Demo()
 
225
        helptext = cmd.get_help_text()
 
226
        self.assertEqualDiff(
 
227
            helptext,
 
228
            'Purpose: A sample command.\n'
 
229
            'Usage:   bzr Demo\n'
 
230
            '\n'
 
231
            'Options:\n'
 
232
            '  --usage        Show usage message and options.\n'
 
233
            '  -v, --verbose  Display more information.\n'
 
234
            '  -q, --quiet    Only display errors and warnings.\n'
 
235
            '  -h, --help     Show help message.\n'
 
236
            '\n'
 
237
            'Description:\n'
 
238
            '  Blah blah blah.\n'
 
239
            '\n'
 
240
            'Formats:\n'
 
241
            '  Interesting stuff about formats.\n'
 
242
            '\n'
 
243
            'Examples:\n'
 
244
            '  Example 1:\n'
 
245
            '\n'
 
246
            '    cmd arg1\n'
 
247
            '\n'
 
248
            'Tips:\n'
 
249
            '  Clever things to keep in mind.\n'
 
250
            '\n')
464
251
 
465
252
    def test_help_text_custom_usage(self):
466
253
        """Help text may contain a custom usage section."""
467
254
        class cmd_Demo(commands.Command):
468
 
            __doc__ = """A sample command.
 
255
            """A sample command.
469
256
 
470
257
            :Usage:
471
258
                cmd Demo [opts] args
474
261
 
475
262
            Blah blah blah.
476
263
            """
477
 
        self.assertCmdHelp('''\
478
 
zz{{:Purpose: zz{{A sample command.}}
479
 
}}zz{{:Usage:
480
 
    zz{{cmd Demo [opts] args}}
481
 
 
482
 
    zz{{cmd Demo -h}}
483
 
 
484
 
}}
485
 
zz{{:Options:
486
 
  --usage        zz{{Show usage message and options.}}
487
 
  -q, --quiet    zz{{Only display errors and warnings.}}
488
 
  -v, --verbose  zz{{Display more information.}}
489
 
  -h, --help     zz{{Show help message.}}
490
 
}}
491
 
Description:
492
 
  zz{{zz{{Blah blah blah.}}
493
 
 
494
 
}}
495
 
''',
496
 
                           cmd_Demo())
497
 
 
498
 
 
499
 
class TestHelp(tests.TestCase):
500
 
 
501
 
    def setUp(self):
502
 
        super(TestHelp, self).setUp()
503
 
        commands.install_bzr_command_hooks()
 
264
        cmd = cmd_Demo()
 
265
        helptext = cmd.get_help_text()
 
266
        self.assertEquals(helptext,
 
267
            'Purpose: A sample command.\n'
 
268
            'Usage:\n'
 
269
            '    cmd Demo [opts] args\n'
 
270
            '\n'
 
271
            '    cmd Demo -h\n'
 
272
            '\n'
 
273
            '\n'
 
274
            'Options:\n'
 
275
            '  --usage        Show usage message and options.\n'
 
276
            '  -v, --verbose  Display more information.\n'
 
277
            '  -q, --quiet    Only display errors and warnings.\n'
 
278
            '  -h, --help     Show help message.\n'
 
279
            '\n'
 
280
            'Description:\n'
 
281
            '  Blah blah blah.\n\n')
504
282
 
505
283
 
506
284
class TestRegisteredTopic(TestHelp):
514
292
        self.assertEqual('basic', topic.topic)
515
293
 
516
294
    def test_get_help_text(self):
517
 
        """RegisteredTopic returns the get_detail results for get_help_text."""
 
295
        """A RegisteredTopic returns the get_detail results for get_help_text."""
518
296
        topic = help_topics.RegisteredTopic('commands')
519
297
        self.assertEqual(help_topics.topic_registry.get_detail('commands'),
520
 
                         topic.get_help_text())
 
298
            topic.get_help_text())
521
299
 
522
300
    def test_get_help_text_with_additional_see_also(self):
523
301
        topic = help_topics.RegisteredTopic('commands')
535
313
            '\n')
536
314
 
537
315
    def test_get_help_topic(self):
538
 
        """The help topic for RegisteredTopic is its topic from construction."""
 
316
        """The help topic for a RegisteredTopic is its topic from construction."""
539
317
        topic = help_topics.RegisteredTopic('foobar')
540
318
        self.assertEqual('foobar', topic.get_help_topic())
541
319
        topic = help_topics.RegisteredTopic('baz')
575
353
        self.assertEqual('', index.prefix)
576
354
 
577
355
 
578
 
class TestConfigOptionIndex(TestHelp):
579
 
    """Tests for the HelpCommandIndex class."""
580
 
 
581
 
    def setUp(self):
582
 
        super(TestConfigOptionIndex, self).setUp()
583
 
        self.index = help_topics.ConfigOptionHelpIndex()
584
 
 
585
 
    def test_get_topics_None(self):
586
 
        """Searching for None returns an empty list."""
587
 
        self.assertEqual([], self.index.get_topics(None))
588
 
 
589
 
    def test_get_topics_no_topic(self):
590
 
        self.assertEqual([], self.index.get_topics('nothing by this name'))
591
 
 
592
 
    def test_prefix(self):
593
 
        self.assertEqual('configuration/', self.index.prefix)
594
 
 
595
 
    def test_get_topic_with_prefix(self):
596
 
        topics = self.index.get_topics('configuration/default_format')
597
 
        self.assertLength(1, topics)
598
 
        opt = topics[0]
599
 
        self.assertIsInstance(opt, config.Option)
600
 
        self.assertEqual('default_format', opt.name)
601
 
 
602
 
 
603
356
class TestCommandIndex(TestHelp):
604
357
    """Tests for the HelpCommandIndex class."""
605
358
 
642
395
    def test_default_search_path(self):
643
396
        """The default search path should include internal indexs."""
644
397
        indices = help.HelpIndices()
645
 
        self.assertEqual(4, len(indices.search_path))
 
398
        self.assertEqual(3, len(indices.search_path))
646
399
        # help topics should be searched in first.
647
400
        self.assertIsInstance(indices.search_path[0],
648
 
                              help_topics.HelpTopicIndex)
 
401
            help_topics.HelpTopicIndex)
649
402
        # with commands being search second.
650
403
        self.assertIsInstance(indices.search_path[1],
651
 
                              commands.HelpCommandIndex)
652
 
        # plugins are a third index.
 
404
            commands.HelpCommandIndex)
 
405
        # and plugins are a third index.
653
406
        self.assertIsInstance(indices.search_path[2],
654
 
                              plugin.PluginsHelpIndex)
655
 
        # config options are a fourth index
656
 
        self.assertIsInstance(indices.search_path[3],
657
 
                              help_topics.ConfigOptionHelpIndex)
 
407
            plugin.PluginsHelpIndex)
658
408
 
659
409
    def test_search_for_unknown_topic_raises(self):
660
410
        """Searching for an unknown topic should raise NoHelpTopic."""