← 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: Canonical.com Patch Queue Manager
  • Date: 2007-06-28 07:08:27 UTC
  • mfrom: (2553.1.3 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070628070827-h5s313dg5tnag9vj
(robertc) Show the names of commit hooks during commit.

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
 
 
19
17
from bzrlib import (
20
18
    builtins,
21
19
    bzrdir,
22
 
    commands,
23
20
    errors,
24
21
    option,
25
22
    repository,
54
51
 
55
52
    def test_option_help(self):
56
53
        """Options have help strings."""
57
 
        out, err = self.run_bzr('commit --help')
58
 
        self.assertContainsRe(out,
59
 
                r'--file(.|\n)*Take commit message from this file\.')
 
54
        out, err = self.run_bzr(['commit', '--help'])
 
55
        self.assertContainsRe(out, r'--file(.|\n)*file containing commit'
 
56
                                   ' message')
60
57
        self.assertContainsRe(out, r'-h.*--help')
61
58
 
62
59
    def test_option_help_global(self):
63
60
        """Global options have help strings."""
64
 
        out, err = self.run_bzr('help status')
65
 
        self.assertContainsRe(out, r'--show-ids.*Show internal object.')
 
61
        out, err = self.run_bzr(['help', 'status'])
 
62
        self.assertContainsRe(out, r'--show-ids.*show internal object')
66
63
 
67
64
    def test_option_arg_help(self):
68
65
        """Help message shows option arguments."""
69
 
        out, err = self.run_bzr('help commit')
 
66
        out, err = self.run_bzr(['help', 'commit'])
70
67
        self.assertEquals(err, '')
71
68
        self.assertContainsRe(out, r'--file[ =]MSGFILE')
72
69
 
73
70
    def test_unknown_short_opt(self):
74
 
        out, err = self.run_bzr('help -r', retcode=3)
 
71
        out, err = self.run_bzr(['help', '-r'], retcode=3)
75
72
        self.assertContainsRe(err, r'no such option')
76
73
 
 
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
 
77
80
    def test_set_short_name(self):
78
81
        o = option.Option('wiggle')
79
82
        o.set_short_name('w')
80
83
        self.assertEqual(o.short_name(), 'w')
81
84
 
 
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
 
82
113
    def test_allow_dash(self):
83
114
        """Test that we can pass a plain '-' as an argument."""
84
115
        self.assertEqual(
236
267
        opts, args = self.parse(
237
268
            options, ['--hello=a', '--hello=b', '--hello=-', '--hello=c'])
238
269
        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))