← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_options.py

  • Committer: Aaron Bentley
  • Date: 2007-07-17 13:27:14 UTC
  • mfrom: (2624 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070717132714-tmzx9khmg9501k51
Merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_options.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import re
 
18
 
17
19
from bzrlib import (
18
20
    builtins,
19
21
    bzrdir,
 
22
    commands,
20
23
    errors,
21
24
    option,
22
25
    repository,
51
54
 
52
55
    def test_option_help(self):
53
56
        """Options have help strings."""
54
 
        out, err = self.run_bzr(['commit', '--help'])
55
 
        self.assertContainsRe(out, r'--file(.|\n)*file containing commit'
56
 
                                   ' message')
 
57
        out, err = self.run_bzr('commit --help')
 
58
        self.assertContainsRe(out,
 
59
                r'--file(.|\n)*Take commit message from this file\.')
57
60
        self.assertContainsRe(out, r'-h.*--help')
58
61
 
59
62
    def test_option_help_global(self):
60
63
        """Global options have help strings."""
61
 
        out, err = self.run_bzr(['help', 'status'])
62
 
        self.assertContainsRe(out, r'--show-ids.*show internal object')
 
64
        out, err = self.run_bzr('help status')
 
65
        self.assertContainsRe(out, r'--show-ids.*Show internal object.')
63
66
 
64
67
    def test_option_arg_help(self):
65
68
        """Help message shows option arguments."""
66
 
        out, err = self.run_bzr(['help', 'commit'])
 
69
        out, err = self.run_bzr('help commit')
67
70
        self.assertEquals(err, '')
68
71
        self.assertContainsRe(out, r'--file[ =]MSGFILE')
69
72
 
70
73
    def test_unknown_short_opt(self):
71
 
        out, err = self.run_bzr(['help', '-r'], retcode=3)
 
74
        out, err = self.run_bzr('help -r', retcode=3)
72
75
        self.assertContainsRe(err, r'no such option')
73
76
 
74
 
    def test_get_short_name(self):
75
 
        file_opt = option.Option.OPTIONS['file']
76
 
        self.assertEquals(file_opt.short_name(), 'F')
77
 
        force_opt = option.Option.OPTIONS['force']
78
 
        self.assertEquals(force_opt.short_name(), None)
79
 
 
80
77
    def test_set_short_name(self):
81
78
        o = option.Option('wiggle')
82
79
        o.set_short_name('w')
83
80
        self.assertEqual(o.short_name(), 'w')
84
81
 
85
 
    def test_old_short_names(self):
86
 
        # test the deprecated method for getting and setting short option
87
 
        # names
88
 
        expected_warning = (
89
 
            "access to SHORT_OPTIONS was deprecated in version 0.14."
90
 
            " Set the short option name when constructing the Option.",
91
 
            DeprecationWarning, 2)
92
 
        _warnings = []
93
 
        def capture_warning(message, category, stacklevel=None):
94
 
            _warnings.append((message, category, stacklevel))
95
 
        old_warning_method = symbol_versioning.warn
96
 
        try:
97
 
            # an example of the kind of thing plugins might want to do through
98
 
            # the old interface - make a new option and then give it a short
99
 
            # name.
100
 
            symbol_versioning.set_warning_method(capture_warning)
101
 
            example_opt = option.Option('example', help='example option')
102
 
            option.Option.SHORT_OPTIONS['w'] = example_opt
103
 
            self.assertEqual(example_opt.short_name(), 'w')
104
 
            self.assertEqual([expected_warning], _warnings)
105
 
            # now check that it can actually be parsed with the registered
106
 
            # value
107
 
            opts, args = parse([example_opt], ['-w', 'foo'])
108
 
            self.assertEqual(opts.example, True)
109
 
            self.assertEqual(args, ['foo'])
110
 
        finally:
111
 
            symbol_versioning.set_warning_method(old_warning_method)
112
 
 
113
82
    def test_allow_dash(self):
114
83
        """Test that we can pass a plain '-' as an argument."""
115
84
        self.assertEqual(
267
236
        opts, args = self.parse(
268
237
            options, ['--hello=a', '--hello=b', '--hello=-', '--hello=c'])
269
238
        self.assertEqual(['c'], opts.hello)
 
239
 
 
240
 
 
241
class TestOptionDefinitions(TestCase):
 
242
    """Tests for options in the Bazaar codebase."""
 
243
 
 
244
    def get_builtin_command_options(self):
 
245
        g = []
 
246
        for cmd_name, cmd_class in sorted(commands.get_all_cmds()):
 
247
            cmd = cmd_class()
 
248
            for opt_name, opt in sorted(cmd.options().items()):
 
249
                g.append((cmd_name, opt))
 
250
        return g
 
251
 
 
252
    def test_global_options_used(self):
 
253
        # In the distant memory, options could only be declared globally.  Now
 
254
        # we prefer to declare them in the command, unless like -r they really
 
255
        # are used very widely with the exact same meaning.  So this checks
 
256
        # for any that should be garbage collected.
 
257
        g = dict(option.Option.OPTIONS.items())
 
258
        used_globals = {}
 
259
        msgs = []
 
260
        for cmd_name, cmd_class in sorted(commands.get_all_cmds()):
 
261
            for option_or_name in sorted(cmd_class.takes_options):
 
262
                if not isinstance(option_or_name, basestring):
 
263
                    self.assertIsInstance(option_or_name, option.Option)
 
264
                elif not option_or_name in g:
 
265
                    msgs.append("apparent reference to undefined "
 
266
                        "global option %r from %r"
 
267
                        % (option_or_name, cmd_class))
 
268
                else:
 
269
                    used_globals.setdefault(option_or_name, []).append(cmd_name)
 
270
        unused_globals = set(g.keys()) - set(used_globals.keys())
 
271
        # not enforced because there might be plugins that use these globals
 
272
        ## for option_name in sorted(unused_globals):
 
273
        ##    msgs.append("unused global option %r" % option_name)
 
274
        ## for option_name, cmds in sorted(used_globals.items()):
 
275
        ##     if len(cmds) <= 1:
 
276
        ##         msgs.append("global option %r is only used by %r"
 
277
        ##                 % (option_name, cmds))
 
278
        if msgs:
 
279
            self.fail("problems with global option definitions:\n"
 
280
                    + '\n'.join(msgs))
 
281
 
 
282
    def test_option_grammar(self):
 
283
        msgs = []
 
284
        # Option help should be written in sentence form, and have a final
 
285
        # period and be all on a single line, because the display code will
 
286
        # wrap it.
 
287
        option_re = re.compile(r'^[A-Z][^\n]+\.$')
 
288
        for scope, option in self.get_builtin_command_options():
 
289
            if not option.help:
 
290
                msgs.append('%-16s %-16s %s' %
 
291
                       ((scope or 'GLOBAL'), option.name, 'NO HELP'))
 
292
            elif not option_re.match(option.help):
 
293
                msgs.append('%-16s %-16s %s' %
 
294
                        ((scope or 'GLOBAL'), option.name, option.help))
 
295
        if msgs:
 
296
            self.fail("The following options don't match the style guide:\n"
 
297
                    + '\n'.join(msgs))