def test_option_value_invalid_nargs(self):
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs='foo')
self.assertEquals(e.exception.message,
"nargs must be a positive integer, '?', '*' or '+'")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=-2)
self.assertEquals(e.exception.message,
"nargs must be a positive integer, '?', '*' or '+'")
def test_option_value_invalid_nargs(self):
with self.assertRaises(InvalidOptionError) as e:
Option("--option", nargs="foo")
self.assertEquals(
str(e.exception), "nargs must be a positive integer, '?', '*' or '+'"
)
with self.assertRaises(InvalidOptionError) as e:
Option("--option", nargs=-2)
self.assertEquals(
str(e.exception), "nargs must be a positive integer, '?', '*' or '+'"
)
def option_impl(self, *args, **kwargs):
'''Implementation of option()
This function creates and returns an Option() object, passing it the
resolved arguments (uses the result of functions when functions are
passed). In most cases, the result of this function is not expected to
be used.
Command line argument/environment variable parsing for this Option is
handled here.
'''
args = [self._resolve(arg) for arg in args]
kwargs = {k: self._resolve(v) for k, v in kwargs.iteritems()}
option = Option(*args, **kwargs)
if option.name in self._options:
raise ConfigureError('Option `%s` already defined' % option.option)
if option.env in self._options:
raise ConfigureError('Option `%s` already defined' % option.env)
if option.name:
self._options[option.name] = option
if option.env:
self._options[option.env] = option
if self._help:
self._help.add(option)
return option
def option_impl(self, *args, **kwargs):
'''Implementation of option()
This function creates and returns an Option() object, passing it the
resolved arguments (uses the result of functions when functions are
passed). In most cases, the result of this function is not expected to
be used.
Command line argument/environment variable parsing for this Option is
handled here.
'''
when = self._normalize_when(kwargs.get('when'), 'option')
args = [self._resolve(arg) for arg in args]
kwargs = {
k: self._resolve(v)
for k, v in six.iteritems(kwargs) if k != 'when'
}
option = Option(*args, **kwargs)
if when:
self._conditions[option] = when
if option.name in self._options:
raise ConfigureError('Option `%s` already defined' % option.option)
if option.env in self._options:
raise ConfigureError('Option `%s` already defined' % option.env)
if option.name:
self._options[option.name] = option
if option.env:
self._options[option.env] = option
if self._help and (when is None or self._value_for(when)):
self._help.add(option)
return option
def option_impl(self, *args, **kwargs):
'''Implementation of option()
This function creates and returns an Option() object, passing it the
resolved arguments (uses the result of functions when functions are
passed). In most cases, the result of this function is not expected to
be used.
Command line argument/environment variable parsing for this Option is
handled here.
'''
when = self._normalize_when(kwargs.get('when'), 'option')
args = [self._resolve(arg) for arg in args]
kwargs = {k: self._resolve(v) for k, v in six.iteritems(kwargs)
if k != 'when'}
# The Option constructor needs to look up the stack to infer a category
# for the Option, since the category is based on the filename where the
# Option is defined. However, if the Option is defined in a template, we
# want the category to reference the caller of the template rather than
# the caller of the option() function.
kwargs['define_depth'] = self._template_depth * 3
option = Option(*args, **kwargs)
if when:
self._conditions[option] = when
if option.name in self._options:
raise ConfigureError('Option `%s` already defined' % option.option)
if option.env in self._options:
raise ConfigureError('Option `%s` already defined' % option.env)
if option.name:
self._options[option.name] = option
if option.env:
self._options[option.env] = option
if self._help and (when is None or self._value_for(when)):
self._help.add(option)
return option
def test_option_value_nargs_2(self):
self.test_option_value(nargs=2)
self.test_option_value(nargs=2, default=('a', 'b'))
self.test_option_value_enable(nargs=2, default=('a', 'b'))
# A default is required
with self.assertRaises(InvalidOptionError):
Option('--disable-option', nargs=2)
def test_basic(self):
helper = CommandLineHelper({}, ['cmd', '--foo', '--bar'])
self.assertEquals(['--foo', '--bar'], list(helper))
helper.add('--enable-qux')
self.assertEquals(['--foo', '--bar', '--enable-qux'], list(helper))
value, option = helper.handle(Option('--bar'))
self.assertEquals(['--foo', '--enable-qux'], list(helper))
self.assertEquals(PositiveOptionValue(), value)
self.assertEquals('--bar', option)
value, option = helper.handle(Option('--baz'))
self.assertEquals(['--foo', '--enable-qux'], list(helper))
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals(None, option)
def test_option_value_nargs_2(self):
self.test_option_value(nargs=2)
self.test_option_value(nargs=2, default=('a', 'b'))
self.test_option_value_enable(nargs=2, default=('a', 'b'))
# A default is required
with self.assertRaises(InvalidOptionError) as e:
Option('--disable-option', nargs=2)
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
def test_option_value_nargs_2(self):
self.test_option_value(nargs=2)
self.test_option_value(nargs=2, default=("a", "b"))
self.test_option_value_enable(nargs=2, default=("a", "b"))
# A default is required
with self.assertRaises(InvalidOptionError) as e:
Option("--disable-option", nargs=2)
self.assertEquals(
str(e.exception), "The given `default` doesn't satisfy `nargs`"
)
def test_basic(self):
helper = CommandLineHelper({}, ["cmd", "--foo", "--bar"])
self.assertEquals(["--foo", "--bar"], list(helper))
helper.add("--enable-qux")
self.assertEquals(["--foo", "--bar", "--enable-qux"], list(helper))
value, option = helper.handle(Option("--bar"))
self.assertEquals(["--foo", "--enable-qux"], list(helper))
self.assertEquals(PositiveOptionValue(), value)
self.assertEquals("--bar", option)
value, option = helper.handle(Option("--baz"))
self.assertEquals(["--foo", "--enable-qux"], list(helper))
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals(None, option)
with self.assertRaises(AssertionError):
CommandLineHelper({}, ["--foo", "--bar"])
def test_option_value_nargs_1_or_more(self):
self.test_option_value(nargs='+')
self.test_option_value(nargs='+', default=('a', ))
self.test_option_value(nargs='+', default=('a', 'b'))
self.test_option_value_enable(nargs='+', default=('a', ))
self.test_option_value_enable(nargs='+', default=('a', 'b'))
# A default is required
with self.assertRaises(InvalidOptionError) as e:
Option('--disable-option', nargs='+')
self.assertEquals(str(e.exception),
"The given `default` doesn't satisfy `nargs`")
def test_option_option(self):
for option in (
'--option',
'--enable-option',
'--disable-option',
'--with-option',
'--without-option',
):
self.assertEquals(Option(option).option, option)
self.assertEquals(Option(option, env='FOO').option, option)
opt = Option(option, default=False)
self.assertEquals(opt.option,
option.replace('-disable-', '-enable-')
.replace('-without-', '-with-'))
opt = Option(option, default=True)
self.assertEquals(opt.option,
option.replace('-enable-', '-disable-')
.replace('-with-', '-without-'))
self.assertEquals(Option(env='FOO').option, 'FOO')
def test_possible_origins(self):
with self.assertRaises(InvalidOptionError):
Option('--foo', possible_origins='command-line')
helper = CommandLineHelper({'BAZ': '1'}, ['cmd', '--foo', '--bar'])
foo = Option('--foo',
possible_origins=('command-line',))
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--foo', option)
bar = Option('--bar',
possible_origins=('mozconfig',))
with self.assertRaisesRegexp(InvalidOptionError,
"--bar can not be set by command-line. Values are accepted from: mozconfig"):
helper.handle(bar)
baz = Option(env='BAZ',
possible_origins=('implied',))
with self.assertRaisesRegexp(InvalidOptionError,
"BAZ=1 can not be set by environment. Values are accepted from: implied"):
helper.handle(baz)
def test_possible_origins(self):
with self.assertRaises(InvalidOptionError):
Option("--foo", possible_origins="command-line")
helper = CommandLineHelper({"BAZ": "1"}, ["cmd", "--foo", "--bar"])
foo = Option("--foo", possible_origins=("command-line",))
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(), value)
self.assertEquals("command-line", value.origin)
self.assertEquals("--foo", option)
bar = Option("--bar", possible_origins=("mozconfig",))
with self.assertRaisesRegexp(
InvalidOptionError,
"--bar can not be set by command-line. Values are accepted from: mozconfig",
):
helper.handle(bar)
baz = Option(env="BAZ", possible_origins=("implied",))
with self.assertRaisesRegexp(
InvalidOptionError,
"BAZ=1 can not be set by environment. Values are accepted from: implied",
):
helper.handle(baz)
def test_option_option(self):
for option in (
"--option",
"--enable-option",
"--disable-option",
"--with-option",
"--without-option",
):
self.assertEquals(Option(option).option, option)
self.assertEquals(Option(option, env="FOO").option, option)
opt = Option(option, default=False)
self.assertEquals(
opt.option,
option.replace("-disable-", "-enable-").replace("-without-", "-with-"),
)
opt = Option(option, default=True)
self.assertEquals(
opt.option,
option.replace("-enable-", "-disable-").replace("-with-", "-without-"),
)
self.assertEquals(Option(env="FOO").option, "FOO")
def _dependency(self, arg, callee_name, arg_name=None):
if isinstance(arg, six.string_types):
prefix, name, values = Option.split_option(arg)
if values != ():
raise ConfigureError("Option must not contain an '='")
if name not in self._options:
raise ConfigureError("'%s' is not a known option. "
"Maybe it's declared too late?" % arg)
arg = self._options[name]
self._seen.add(arg)
elif isinstance(arg, SandboxDependsFunction):
assert arg in self._depends
arg = self._depends[arg]
else:
raise TypeError(
"Cannot use object of type '%s' as %sargument to %s" %
(type(arg).__name__, '`%s` ' % arg_name if arg_name else '',
callee_name))
return arg
def option_impl(self, *args, **kwargs):
'''Implementation of option()
This function creates and returns an Option() object, passing it the
resolved arguments (uses the result of functions when functions are
passed). In most cases, the result of this function is not expected to
be used.
Command line argument/environment variable parsing for this Option is
handled here.
'''
args = [self._resolve(arg) for arg in args]
kwargs = {k: self._resolve(v) for k, v in kwargs.iteritems()}
option = Option(*args, **kwargs)
if option.name in self._options:
raise ConfigureError('Option `%s` already defined' %
self._options[option.name].option)
if option.env in self._options:
raise ConfigureError('Option `%s` already defined' %
self._options[option.env].option)
if option.name:
self._options[option.name] = option
if option.env:
self._options[option.env] = option
try:
value, option_string = self._helper.handle(option)
except ConflictingOptionError as e:
frameinfo, reason = self._implied_options[e.arg]
raise InvalidOptionError(
"'%s' implied by '%s' conflicts with '%s' from the %s" %
(e.arg, reason, e.old_arg, e.old_origin))
if self._help:
self._help.add(option)
self._option_values[option] = value
self._raw_options[option] = (option_string.split('=', 1)[0]
if option_string else option_string)
return option
def test_option_value(self, name='option', nargs=0, default=None):
disabled = name.startswith(('disable-', 'without-'))
if disabled:
negOptionValue = PositiveOptionValue
posOptionValue = NegativeOptionValue
else:
posOptionValue = PositiveOptionValue
negOptionValue = NegativeOptionValue
defaultValue = (PositiveOptionValue(default)
if default else negOptionValue())
option = Option('--%s' % name, nargs=nargs, default=default)
if nargs in (0, '?', '*') or disabled:
value = option.get_value('--%s' % name, 'option')
self.assertEquals(value, posOptionValue())
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s' % name)
if nargs == 1:
self.assertEquals(e.exception.message,
'--%s takes 1 value' % name)
elif nargs == '+':
self.assertEquals(e.exception.message,
'--%s takes 1 or more values' % name)
else:
self.assertEquals(e.exception.message,
'--%s takes 2 values' % name)
value = option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value(None)
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
with self.assertRaises(AssertionError):
value = option.get_value('MOZ_OPTION=', 'environment')
with self.assertRaises(AssertionError):
value = option.get_value('MOZ_OPTION=1', 'environment')
with self.assertRaises(AssertionError):
value = option.get_value('--foo')
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('', )))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s=' % name)
if disabled:
self.assertEquals(e.exception.message,
'Cannot pass a value to --%s' % name)
else:
self.assertEquals(e.exception.message,
'--%s takes %d values' % (name, nargs))
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=foo' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('foo', )))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s=foo' % name)
if disabled:
self.assertEquals(e.exception.message,
'Cannot pass a value to --%s' % name)
else:
self.assertEquals(e.exception.message,
'--%s takes %d values' % (name, nargs))
if nargs in (2, '*', '+') and not disabled:
value = option.get_value('--%s=foo,bar' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s=foo,bar' % name, 'option')
if disabled:
self.assertEquals(e.exception.message,
'Cannot pass a value to --%s' % name)
elif nargs == '?':
self.assertEquals(e.exception.message,
'--%s takes 0 or 1 values' % name)
else:
self.assertEquals(
e.exception.message, '--%s takes %d value%s' %
(name, nargs, 's' if nargs != 1 else ''))
option = Option('--%s' % name,
env='MOZ_OPTION',
nargs=nargs,
default=default)
if nargs in (0, '?', '*') or disabled:
value = option.get_value('--%s' % name, 'option')
self.assertEquals(value, posOptionValue())
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s' % name)
if disabled:
self.assertEquals(e.exception.message,
'Cannot pass a value to --%s' % name)
elif nargs == '+':
self.assertEquals(e.exception.message,
'--%s takes 1 or more values' % name)
else:
self.assertEquals(
e.exception.message, '--%s takes %d value%s' %
(name, nargs, 's' if nargs != 1 else ''))
value = option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value(None)
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value('MOZ_OPTION=', 'environment')
self.assertEquals(value, NegativeOptionValue())
self.assertEquals(value.origin, 'environment')
if nargs in (0, '?', '*'):
value = option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue())
self.assertEquals(value.origin, 'environment')
elif nargs in (1, '+'):
value = option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue(('1', )))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(e.exception.message, 'MOZ_OPTION takes 2 values')
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('', )))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--%s=' % name, 'option')
if disabled:
self.assertEquals(e.exception.message,
'Cannot pass a value to --%s' % name)
else:
self.assertEquals(e.exception.message,
'--%s takes %d values' % (name, nargs))
with self.assertRaises(AssertionError):
value = option.get_value('--foo', 'option')
if nargs in (1, '?', '*', '+'):
value = option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', )))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(e.exception.message,
'MOZ_OPTION takes %d values' % nargs)
if nargs in (2, '*', '+'):
value = option.get_value('MOZ_OPTION=foo,bar', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
option.get_value('MOZ_OPTION=foo,bar', 'environment')
if nargs == '?':
self.assertEquals(e.exception.message,
'MOZ_OPTION takes 0 or 1 values')
else:
self.assertEquals(
e.exception.message, 'MOZ_OPTION takes %d value%s' %
(nargs, 's' if nargs != 1 else ''))
if disabled:
return option
env_option = Option(env='MOZ_OPTION', nargs=nargs, default=default)
with self.assertRaises(AssertionError):
env_option.get_value('--%s' % name)
value = env_option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = env_option.get_value('MOZ_OPTION=', 'environment')
self.assertEquals(value, negOptionValue())
self.assertEquals(value.origin, 'environment')
if nargs in (0, '?', '*'):
value = env_option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, posOptionValue())
self.assertTrue(value)
self.assertEquals(value.origin, 'environment')
elif nargs in (1, '+'):
value = env_option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue(('1', )))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
env_option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(e.exception.message, 'MOZ_OPTION takes 2 values')
with self.assertRaises(AssertionError) as e:
env_option.get_value('--%s' % name)
with self.assertRaises(AssertionError) as e:
env_option.get_value('--foo')
if nargs in (1, '?', '*', '+'):
value = env_option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', )))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
env_option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(e.exception.message,
'MOZ_OPTION takes %d values' % nargs)
if nargs in (2, '*', '+'):
value = env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError) as e:
env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
if nargs == '?':
self.assertEquals(e.exception.message,
'MOZ_OPTION takes 0 or 1 values')
else:
self.assertEquals(
e.exception.message, 'MOZ_OPTION takes %d value%s' %
(nargs, 's' if nargs != 1 else ''))
return option
def imply_option_impl(self, option, value, reason=None, when=None):
'''Implementation of imply_option().
Injects additional options as if they had been passed on the command
line. The `option` argument is a string as in option()'s `name` or
`env`. The option must be declared after `imply_option` references it.
The `value` argument indicates the value to pass to the option.
It can be:
- True. In this case `imply_option` injects the positive option
(--enable-foo/--with-foo).
imply_option('--enable-foo', True)
imply_option('--disable-foo', True)
are both equivalent to `--enable-foo` on the command line.
- False. In this case `imply_option` injects the negative option
(--disable-foo/--without-foo).
imply_option('--enable-foo', False)
imply_option('--disable-foo', False)
are both equivalent to `--disable-foo` on the command line.
- None. In this case `imply_option` does nothing.
imply_option('--enable-foo', None)
imply_option('--disable-foo', None)
are both equivalent to not passing any flag on the command line.
- a string or a tuple. In this case `imply_option` injects the positive
option with the given value(s).
imply_option('--enable-foo', 'a')
imply_option('--disable-foo', 'a')
are both equivalent to `--enable-foo=a` on the command line.
imply_option('--enable-foo', ('a', 'b'))
imply_option('--disable-foo', ('a', 'b'))
are both equivalent to `--enable-foo=a,b` on the command line.
Because imply_option('--disable-foo', ...) can be misleading, it is
recommended to use the positive form ('--enable' or '--with') for
`option`.
The `value` argument can also be (and usually is) a reference to a
@depends function, in which case the result of that function will be
used as per the descripted mapping above.
The `reason` argument indicates what caused the option to be implied.
It is necessary when it cannot be inferred from the `value`.
'''
when = self._normalize_when(when, 'imply_option')
# Don't do anything when --help was on the command line
if self._help:
return
if not reason and isinstance(value, SandboxDependsFunction):
deps = self._depends[value].dependencies
possible_reasons = [d for d in deps if d != self._help_option]
if len(possible_reasons) == 1:
if isinstance(possible_reasons[0], Option):
reason = possible_reasons[0]
if not reason and (isinstance(value, (bool, tuple)) or
isinstance(value, six.string_types)):
# A reason can be provided automatically when imply_option
# is called with an immediate value.
_, filename, line, _, _, _ = inspect.stack()[1]
reason = "imply_option at %s:%s" % (filename, line)
if not reason:
raise ConfigureError(
"Cannot infer what implies '%s'. Please add a `reason` to "
"the `imply_option` call."
% option)
prefix, name, values = Option.split_option(option)
if values != ():
raise ConfigureError("Implied option must not contain an '='")
self._implied_options.append(ReadOnlyNamespace(
option=option,
prefix=prefix,
name=name,
value=value,
caller=inspect.stack()[1],
reason=reason,
when=when,
))
def test_option_choices(self):
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=3, choices=('a', 'b'))
self.assertEquals(e.exception.message,
'Not enough `choices` for `nargs`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', nargs=1, choices=('a', 'b'))
self.assertEquals(e.exception.message,
'A `default` must be given along with `choices`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', nargs='+', choices=('a', 'b'))
self.assertEquals(e.exception.message,
'A `default` must be given along with `choices`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', default='c', choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option',
default=(
'a',
'c',
),
choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', default=('c', ), choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
option = Option('--with-option', nargs='+', choices=('a', 'b'))
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=c')
self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
option = Option('--without-option',
nargs='*',
default='a',
choices=('a', 'b'))
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=c')
self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
# Test nargs inference from choices
option = Option('--with-option', choices=('a', 'b'))
self.assertEqual(option.nargs, 1)
# Test "relative" values
option = Option('--with-option',
nargs='*',
default=('b', 'c'),
choices=('a', 'b', 'c', 'd'))
value = option.get_value('--with-option=+d')
self.assertEquals(PositiveOptionValue(('b', 'c', 'd')), value)
value = option.get_value('--with-option=-b')
self.assertEquals(PositiveOptionValue(('c', )), value)
value = option.get_value('--with-option=-b,+d')
self.assertEquals(PositiveOptionValue(('c', 'd')), value)
# Adding something that is in the default is fine
value = option.get_value('--with-option=+b')
self.assertEquals(PositiveOptionValue(('b', 'c')), value)
# Removing something that is not in the default is fine, as long as it
# is one of the choices
value = option.get_value('--with-option=-a')
self.assertEquals(PositiveOptionValue(('b', 'c')), value)
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=-e')
self.assertEquals(e.exception.message,
"'e' is not one of 'a', 'b', 'c', 'd'")
# Other "not a choice" errors.
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=+e')
self.assertEquals(e.exception.message,
"'e' is not one of 'a', 'b', 'c', 'd'")
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=e')
self.assertEquals(e.exception.message,
"'e' is not one of 'a', 'b', 'c', 'd'")
def depends_impl(self, *args):
'''Implementation of @depends()
This function is a decorator. It returns a function that subsequently
takes a function and returns a dummy function. The dummy function
identifies the actual function for the sandbox, while preventing
further function calls from within the sandbox.
@depends() takes a variable number of option strings or dummy function
references. The decorated function is called as soon as the decorator
is called, and the arguments it receives are the OptionValue or
function results corresponding to each of the arguments to @depends.
As an exception, when a HelpFormatter is attached, only functions that
have '--help' in their @depends argument list are called.
The decorated function is altered to use a different global namespace
for its execution. This different global namespace exposes a limited
set of functions from os.path.
'''
if not args:
raise ConfigureError('@depends needs at least one argument')
resolved_args = []
dependencies = []
for arg in args:
if isinstance(arg, types.StringTypes):
prefix, name, values = Option.split_option(arg)
if values != ():
raise ConfigureError("Option must not contain an '='")
if name not in self._options:
raise ConfigureError("'%s' is not a known option. "
"Maybe it's declared too late?" % arg)
arg = self._options[name]
self._seen.add(arg)
dependencies.append(arg)
assert arg in self._option_values or self._help
resolved_arg = self._option_values.get(arg)
elif isinstance(arg, DummyFunction):
assert arg in self._depends
dependencies.append(arg)
arg, _ = self._depends[arg]
resolved_arg = self._results.get(arg)
else:
raise TypeError(
"Cannot use object of type '%s' as argument to @depends" %
type(arg))
resolved_args.append(resolved_arg)
dependencies = tuple(dependencies)
def decorator(func):
if inspect.isgeneratorfunction(func):
raise ConfigureError(
'Cannot decorate generator functions with @depends')
func, glob = self._prepare_function(func)
dummy = wraps(func)(DummyFunction())
self._depends[dummy] = func, dependencies
with_help = self._help_option in dependencies
if with_help:
for arg in args:
if isinstance(arg, DummyFunction):
_, deps = self._depends[arg]
if self._help_option not in deps:
raise ConfigureError(
"`%s` depends on '--help' and `%s`. "
"`%s` must depend on '--help'" %
(func.__name__, arg.__name__, arg.__name__))
if not self._help or with_help:
self._results[func] = func(*resolved_args)
return dummy
return decorator
def test_precedence(self):
foo = Option('--with-foo', nargs='*')
helper = CommandLineHelper({}, ['cmd', '--with-foo=a,b'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--with-foo=a,b', option)
helper = CommandLineHelper({},
['cmd', '--with-foo=a,b', '--without-foo'])
value, option = helper.handle(foo)
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--without-foo', option)
helper = CommandLineHelper({},
['cmd', '--without-foo', '--with-foo=a,b'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--with-foo=a,b', option)
foo = Option('--with-foo', env='FOO', nargs='*')
helper = CommandLineHelper({'FOO': ''}, ['cmd', '--with-foo=a,b'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--with-foo=a,b', option)
helper = CommandLineHelper({'FOO': 'a,b'}, ['cmd', '--without-foo'])
value, option = helper.handle(foo)
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--without-foo', option)
helper = CommandLineHelper({'FOO': ''}, ['cmd', '--with-bar=a,b'])
value, option = helper.handle(foo)
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals('environment', value.origin)
self.assertEquals('FOO=', option)
helper = CommandLineHelper({'FOO': 'a,b'}, ['cmd', '--without-bar'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('environment', value.origin)
self.assertEquals('FOO=a,b', option)
helper = CommandLineHelper({}, ['cmd', '--with-foo=a,b', 'FOO='])
value, option = helper.handle(foo)
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('FOO=', option)
helper = CommandLineHelper({}, ['cmd', '--without-foo', 'FOO=a,b'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('FOO=a,b', option)
helper = CommandLineHelper({}, ['cmd', 'FOO=', '--with-foo=a,b'])
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b')), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--with-foo=a,b', option)
helper = CommandLineHelper({}, ['cmd', 'FOO=a,b', '--without-foo'])
value, option = helper.handle(foo)
self.assertEquals(NegativeOptionValue(), value)
self.assertEquals('command-line', value.origin)
self.assertEquals('--without-foo', option)
def test_extra_args(self):
foo = Option('--with-foo', env='FOO', nargs='*')
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b', 'c')), value)
self.assertEquals('other-origin', value.origin)
self.assertEquals('FOO=a,b,c', option)
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
helper.add('--with-foo=a,b,c', 'other-origin')
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b', 'c')), value)
self.assertEquals('other-origin', value.origin)
self.assertEquals('--with-foo=a,b,c', option)
# Adding conflicting options is not allowed.
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
with self.assertRaises(ConflictingOptionError) as cm:
helper.add('FOO=', 'other-origin')
self.assertEqual('FOO=', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('FOO=a,b,c', cm.exception.old_arg)
self.assertEqual('other-origin', cm.exception.old_origin)
with self.assertRaises(ConflictingOptionError) as cm:
helper.add('FOO=a,b', 'other-origin')
self.assertEqual('FOO=a,b', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('FOO=a,b,c', cm.exception.old_arg)
self.assertEqual('other-origin', cm.exception.old_origin)
# But adding the same is allowed.
helper.add('FOO=a,b,c', 'other-origin')
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b', 'c')), value)
self.assertEquals('other-origin', value.origin)
self.assertEquals('FOO=a,b,c', option)
# The same rule as above applies when using the option form vs. the
# variable form. But we can't detect it when .add is called.
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
helper.add('--without-foo', 'other-origin')
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual('--without-foo', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('FOO=a,b,c', cm.exception.old_arg)
self.assertEqual('other-origin', cm.exception.old_origin)
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
helper.add('--with-foo=a,b', 'other-origin')
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual('--with-foo=a,b', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('FOO=a,b,c', cm.exception.old_arg)
self.assertEqual('other-origin', cm.exception.old_origin)
helper = CommandLineHelper({}, ['cmd'])
helper.add('FOO=a,b,c', 'other-origin')
helper.add('--with-foo=a,b,c', 'other-origin')
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(('a', 'b', 'c')), value)
self.assertEquals('other-origin', value.origin)
self.assertEquals('--with-foo=a,b,c', option)
# Conflicts are also not allowed against what is in the
# environment/on the command line.
helper = CommandLineHelper({}, ['cmd', '--with-foo=a,b'])
helper.add('FOO=a,b,c', 'other-origin')
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual('FOO=a,b,c', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('--with-foo=a,b', cm.exception.old_arg)
self.assertEqual('command-line', cm.exception.old_origin)
helper = CommandLineHelper({}, ['cmd', '--with-foo=a,b'])
helper.add('--without-foo', 'other-origin')
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual('--without-foo', cm.exception.arg)
self.assertEqual('other-origin', cm.exception.origin)
self.assertEqual('--with-foo=a,b', cm.exception.old_arg)
self.assertEqual('command-line', cm.exception.old_origin)
def test_option_value(self, name='option', nargs=0, default=None):
disabled = name.startswith(('disable-', 'without-'))
if disabled:
negOptionValue = PositiveOptionValue
posOptionValue = NegativeOptionValue
else:
posOptionValue = PositiveOptionValue
negOptionValue = NegativeOptionValue
defaultValue = (PositiveOptionValue(default)
if default else negOptionValue())
option = Option('--%s' % name, nargs=nargs, default=default)
if nargs in (0, '?', '*') or disabled:
value = option.get_value('--%s' % name, 'option')
self.assertEquals(value, posOptionValue())
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s' % name)
value = option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value(None)
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
with self.assertRaises(AssertionError):
value = option.get_value('MOZ_OPTION=', 'environment')
with self.assertRaises(AssertionError):
value = option.get_value('MOZ_OPTION=1', 'environment')
with self.assertRaises(AssertionError):
value = option.get_value('--foo')
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('',)))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s=' % name)
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=foo' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('foo',)))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s=foo' % name)
if nargs in (2, '*', '+') and not disabled:
value = option.get_value('--%s=foo,bar' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s=foo,bar' % name, 'option')
option = Option('--%s' % name, env='MOZ_OPTION', nargs=nargs,
default=default)
if nargs in (0, '?', '*') or disabled:
value = option.get_value('--%s' % name, 'option')
self.assertEquals(value, posOptionValue())
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s' % name)
value = option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value(None)
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = option.get_value('MOZ_OPTION=', 'environment')
self.assertEquals(value, NegativeOptionValue())
self.assertEquals(value.origin, 'environment')
if nargs in (0, '?', '*'):
value = option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue())
self.assertEquals(value.origin, 'environment')
elif nargs in (1, '+'):
value = option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue(('1',)))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('MOZ_OPTION=1', 'environment')
if nargs in (1, '?', '*', '+') and not disabled:
value = option.get_value('--%s=' % name, 'option')
self.assertEquals(value, PositiveOptionValue(('',)))
self.assertEquals(value.origin, 'option')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('--%s=' % name, 'option')
with self.assertRaises(AssertionError):
value = option.get_value('--foo', 'option')
if nargs in (1, '?', '*', '+'):
value = option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo',)))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('MOZ_OPTION=foo', 'environment')
if nargs in (2, '*', '+'):
value = option.get_value('MOZ_OPTION=foo,bar', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
option.get_value('MOZ_OPTION=foo,bar', 'environment')
if disabled:
return option
env_option = Option(env='MOZ_OPTION', nargs=nargs, default=default)
with self.assertRaises(AssertionError):
env_option.get_value('--%s' % name)
value = env_option.get_value('')
self.assertEquals(value, defaultValue)
self.assertEquals(value.origin, 'default')
value = env_option.get_value('MOZ_OPTION=', 'environment')
self.assertEquals(value, negOptionValue())
self.assertEquals(value.origin, 'environment')
if nargs in (0, '?', '*'):
value = env_option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, posOptionValue())
self.assertTrue(value)
self.assertEquals(value.origin, 'environment')
elif nargs in (1, '+'):
value = env_option.get_value('MOZ_OPTION=1', 'environment')
self.assertEquals(value, PositiveOptionValue(('1',)))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
env_option.get_value('MOZ_OPTION=1', 'environment')
with self.assertRaises(AssertionError):
env_option.get_value('--%s' % name)
with self.assertRaises(AssertionError):
env_option.get_value('--foo')
if nargs in (1, '?', '*', '+'):
value = env_option.get_value('MOZ_OPTION=foo', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo',)))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
env_option.get_value('MOZ_OPTION=foo', 'environment')
if nargs in (2, '*', '+'):
value = env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
self.assertEquals(value, PositiveOptionValue(('foo', 'bar')))
self.assertEquals(value.origin, 'environment')
else:
with self.assertRaises(InvalidOptionError):
env_option.get_value('MOZ_OPTION=foo,bar', 'environment')
return option
def test_option_choices(self):
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=3, choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--without-option', nargs=1, choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--without-option', nargs='+', choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--without-option', default='c', choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--without-option', default=('a', 'c',), choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--without-option', default=('c',), choices=('a', 'b'))
option = Option('--with-option', nargs='+', choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
option.get_value('--with-option=c')
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
option = Option('--without-option', nargs='*', default='a',
choices=('a', 'b'))
with self.assertRaises(InvalidOptionError):
option.get_value('--with-option=c')
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
# Test nargs inference from choices
option = Option('--with-option', choices=('a', 'b'))
self.assertEqual(option.nargs, 1)
def test_option(self):
option = Option('--option')
self.assertEquals(option.prefix, '')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--enable-option')
self.assertEquals(option.prefix, 'enable')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--disable-option')
self.assertEquals(option.prefix, 'disable')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertTrue(option.default)
option = Option('--with-option')
self.assertEquals(option.prefix, 'with')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--without-option')
self.assertEquals(option.prefix, 'without')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertTrue(option.default)
option = Option('--without-option-foo', env='MOZ_OPTION')
self.assertEquals(option.env, 'MOZ_OPTION')
option = Option(env='MOZ_OPTION')
self.assertEquals(option.prefix, '')
self.assertEquals(option.name, None)
self.assertEquals(option.env, 'MOZ_OPTION')
self.assertFalse(option.default)
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=0, default=('a',))
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=1, default=())
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=1, default=True)
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=1, default=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=2, default=())
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=2, default=True)
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=2, default=('a',))
with self.assertRaises(InvalidOptionError):
Option('--option', nargs='?', default=('a', 'b'))
with self.assertRaises(InvalidOptionError):
Option('--option', nargs='+', default=())
with self.assertRaises(InvalidOptionError):
Option('--option', nargs='+', default=True)
# --disable options with a nargs value that requires at least one
# argument need to be given a default.
with self.assertRaises(InvalidOptionError):
Option('--disable-option', nargs=1)
with self.assertRaises(InvalidOptionError):
Option('--disable-option', nargs='+')
# Test nargs inference from default value
option = Option('--with-foo', default=True)
self.assertEquals(option.nargs, 0)
option = Option('--with-foo', default=False)
self.assertEquals(option.nargs, 0)
option = Option('--with-foo', default='a')
self.assertEquals(option.nargs, '?')
option = Option('--with-foo', default=('a',))
self.assertEquals(option.nargs, '?')
option = Option('--with-foo', default=('a', 'b'))
self.assertEquals(option.nargs, '*')
option = Option(env='FOO', default=True)
self.assertEquals(option.nargs, 0)
option = Option(env='FOO', default=False)
self.assertEquals(option.nargs, 0)
option = Option(env='FOO', default='a')
self.assertEquals(option.nargs, '?')
option = Option(env='FOO', default=('a',))
self.assertEquals(option.nargs, '?')
option = Option(env='FOO', default=('a', 'b'))
self.assertEquals(option.nargs, '*')
def test_option_value_invalid_nargs(self):
with self.assertRaises(InvalidOptionError):
Option('--option', nargs='foo')
with self.assertRaises(InvalidOptionError):
Option('--option', nargs=-2)
def test_option(self):
option = Option('--option')
self.assertEquals(option.prefix, '')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--enable-option')
self.assertEquals(option.prefix, 'enable')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--disable-option')
self.assertEquals(option.prefix, 'disable')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertTrue(option.default)
option = Option('--with-option')
self.assertEquals(option.prefix, 'with')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertFalse(option.default)
option = Option('--without-option')
self.assertEquals(option.prefix, 'without')
self.assertEquals(option.name, 'option')
self.assertEquals(option.env, None)
self.assertTrue(option.default)
option = Option('--without-option-foo', env='MOZ_OPTION')
self.assertEquals(option.env, 'MOZ_OPTION')
option = Option(env='MOZ_OPTION')
self.assertEquals(option.prefix, '')
self.assertEquals(option.name, None)
self.assertEquals(option.env, 'MOZ_OPTION')
self.assertFalse(option.default)
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=0, default=('a', ))
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=1, default=())
self.assertEquals(
e.exception.message,
'default must be a bool, a string or a tuple of strings')
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=1, default=True)
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=1, default=('a', 'b'))
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=2, default=())
self.assertEquals(
e.exception.message,
'default must be a bool, a string or a tuple of strings')
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=2, default=True)
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=2, default=('a', ))
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs='?', default=('a', 'b'))
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs='+', default=())
self.assertEquals(
e.exception.message,
'default must be a bool, a string or a tuple of strings')
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs='+', default=True)
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
# --disable options with a nargs value that requires at least one
# argument need to be given a default.
with self.assertRaises(InvalidOptionError) as e:
Option('--disable-option', nargs=1)
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
with self.assertRaises(InvalidOptionError) as e:
Option('--disable-option', nargs='+')
self.assertEquals(e.exception.message,
"The given `default` doesn't satisfy `nargs`")
# Test nargs inference from default value
option = Option('--with-foo', default=True)
self.assertEquals(option.nargs, 0)
option = Option('--with-foo', default=False)
self.assertEquals(option.nargs, 0)
option = Option('--with-foo', default='a')
self.assertEquals(option.nargs, '?')
option = Option('--with-foo', default=('a', ))
self.assertEquals(option.nargs, '?')
option = Option('--with-foo', default=('a', 'b'))
self.assertEquals(option.nargs, '*')
option = Option(env='FOO', default=True)
self.assertEquals(option.nargs, 0)
option = Option(env='FOO', default=False)
self.assertEquals(option.nargs, 0)
option = Option(env='FOO', default='a')
self.assertEquals(option.nargs, '?')
option = Option(env='FOO', default=('a', ))
self.assertEquals(option.nargs, '?')
option = Option(env='FOO', default=('a', 'b'))
self.assertEquals(option.nargs, '*')
def test_option_choices(self):
with self.assertRaises(InvalidOptionError) as e:
Option('--option', nargs=3, choices=('a', 'b'))
self.assertEquals(e.exception.message,
'Not enough `choices` for `nargs`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', nargs=1, choices=('a', 'b'))
self.assertEquals(e.exception.message,
'A `default` must be given along with `choices`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', nargs='+', choices=('a', 'b'))
self.assertEquals(e.exception.message,
'A `default` must be given along with `choices`')
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', default='c', choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option',
default=(
'a',
'c',
),
choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
with self.assertRaises(InvalidOptionError) as e:
Option('--without-option', default=('c', ), choices=('a', 'b'))
self.assertEquals(e.exception.message,
"The `default` value must be one of 'a', 'b'")
option = Option('--with-option', nargs='+', choices=('a', 'b'))
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=c')
self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
option = Option('--without-option',
nargs='*',
default='a',
choices=('a', 'b'))
with self.assertRaises(InvalidOptionError) as e:
option.get_value('--with-option=c')
self.assertEquals(e.exception.message, "'c' is not one of 'a', 'b'")
value = option.get_value('--with-option=b,a')
self.assertTrue(value)
self.assertEquals(PositiveOptionValue(('b', 'a')), value)
# Test nargs inference from choices
option = Option('--with-option', choices=('a', 'b'))
self.assertEqual(option.nargs, 1)
def test_extra_args(self):
foo = Option("--with-foo", env="FOO", nargs="*")
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(("a", "b", "c")), value)
self.assertEquals("other-origin", value.origin)
self.assertEquals("FOO=a,b,c", option)
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
helper.add("--with-foo=a,b,c", "other-origin")
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(("a", "b", "c")), value)
self.assertEquals("other-origin", value.origin)
self.assertEquals("--with-foo=a,b,c", option)
# Adding conflicting options is not allowed.
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
with self.assertRaises(ConflictingOptionError) as cm:
helper.add("FOO=", "other-origin")
self.assertEqual("FOO=", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("FOO=a,b,c", cm.exception.old_arg)
self.assertEqual("other-origin", cm.exception.old_origin)
with self.assertRaises(ConflictingOptionError) as cm:
helper.add("FOO=a,b", "other-origin")
self.assertEqual("FOO=a,b", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("FOO=a,b,c", cm.exception.old_arg)
self.assertEqual("other-origin", cm.exception.old_origin)
# But adding the same is allowed.
helper.add("FOO=a,b,c", "other-origin")
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(("a", "b", "c")), value)
self.assertEquals("other-origin", value.origin)
self.assertEquals("FOO=a,b,c", option)
# The same rule as above applies when using the option form vs. the
# variable form. But we can't detect it when .add is called.
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
helper.add("--without-foo", "other-origin")
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual("--without-foo", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("FOO=a,b,c", cm.exception.old_arg)
self.assertEqual("other-origin", cm.exception.old_origin)
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
helper.add("--with-foo=a,b", "other-origin")
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual("--with-foo=a,b", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("FOO=a,b,c", cm.exception.old_arg)
self.assertEqual("other-origin", cm.exception.old_origin)
helper = CommandLineHelper({}, ["cmd"])
helper.add("FOO=a,b,c", "other-origin")
helper.add("--with-foo=a,b,c", "other-origin")
value, option = helper.handle(foo)
self.assertEquals(PositiveOptionValue(("a", "b", "c")), value)
self.assertEquals("other-origin", value.origin)
self.assertEquals("--with-foo=a,b,c", option)
# Conflicts are also not allowed against what is in the
# environment/on the command line.
helper = CommandLineHelper({}, ["cmd", "--with-foo=a,b"])
helper.add("FOO=a,b,c", "other-origin")
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual("FOO=a,b,c", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("--with-foo=a,b", cm.exception.old_arg)
self.assertEqual("command-line", cm.exception.old_origin)
helper = CommandLineHelper({}, ["cmd", "--with-foo=a,b"])
helper.add("--without-foo", "other-origin")
with self.assertRaises(ConflictingOptionError) as cm:
helper.handle(foo)
self.assertEqual("--without-foo", cm.exception.arg)
self.assertEqual("other-origin", cm.exception.origin)
self.assertEqual("--with-foo=a,b", cm.exception.old_arg)
self.assertEqual("command-line", cm.exception.old_origin)
