def test_value_inheritance(self):
option_list = [
options.Option('-a', dest='a'),
options.Option('-b', dest='b')
]
values, leftovers = options.parser().options(option_list).parse([])
assert not hasattr(values, 'a')
assert not hasattr(values, 'b')
# w/ option
values, leftovers = options.parser().options(option_list).parse(
['-a', 'value_a'])
assert hasattr(values, 'a')
assert values.a == 'value_a'
assert not hasattr(values, 'b')
# w/ inherited option
values, leftovers = options.parser().values(values).options(
option_list).parse(['-b', 'value_b'])
assert values.a == 'value_a'
assert values.b == 'value_b'
# w/ inherits w/o parsing any new args
values, leftovers = options.parser().values(values).options(
option_list).parse([])
assert values.a == 'value_a'
assert values.b == 'value_b'
# w/ overwrites despite inheriting
values, leftovers = options.parser().values(values).options(
option_list).parse(['-a', 'new_value_a'])
assert values.a == 'new_value_a'
assert values.b == 'value_b'
def test_value_inheritance(self):
option_list = [options.Option("-a", dest="a"), options.Option("-b", dest="b")]
values, leftovers = options.parser().options(option_list).parse([])
assert not hasattr(values, "a")
assert not hasattr(values, "b")
# w/ option
values, leftovers = options.parser().options(option_list).parse(["-a", "value_a"])
assert hasattr(values, "a")
assert values.a == "value_a"
assert not hasattr(values, "b")
# w/ inherited option
values, leftovers = options.parser().values(values).options(option_list).parse(["-b", "value_b"])
assert values.a == "value_a"
assert values.b == "value_b"
# w/ inherits w/o parsing any new args
values, leftovers = options.parser().values(values).options(option_list).parse([])
assert values.a == "value_a"
assert values.b == "value_b"
# w/ overwrites despite inheriting
values, leftovers = options.parser().values(values).options(option_list).parse(["-a", "new_value_a"])
assert values.a == "new_value_a"
assert values.b == "value_b"
def test_basic_parsing(self):
option = options.Option('-m', '--my_option', dest='my_option')
# w/o option
values, leftovers = options.parser().options([option]).parse([])
assert not hasattr(values, 'my_option')
assert leftovers == []
# w/ option
values, leftovers = options.parser().options([option
]).parse(['-m', 'poop'])
assert values.my_option == 'poop'
assert leftovers == []
# w/ long option
values, leftovers = options.parser().options([option]).parse(
['--my_option', 'plork'])
assert values.my_option == 'plork'
assert leftovers == []
# w/ option and leftover
values, leftovers = options.parser().options([option]).parse(
['--my_option', 'plork', 'hork'])
assert values.my_option == 'plork'
assert leftovers == ['hork']
def test_groups(self):
option_a = options.Option('-a', dest='a')
option_b = options.Option('-b', dest='b')
option_group_a = options.group('a')
option_group_b = options.group('b')
option_group_a.add_option(options.Option('--a1', dest='a1'),
options.Option('--a2', dest='a2'))
option_group_b.add_option(options.Option('--b1', dest='b1'),
options.Option('--b2', dest='b2'))
partial_parser = (options.parser().interspersed_arguments(True).groups(
[option_group_a, option_group_b]))
full_parser = partial_parser.options([option_a, option_b])
parameters = [
'--a1', 'value_a1', '--a2', 'value_a2', '--b1', 'value_b1', '--b2',
'value_b2'
]
full_parameters = parameters + ['-a', 'value_a', '-b', 'value_b']
values, leftovers = partial_parser.parse(parameters)
assert values.a1 == 'value_a1'
assert values.a2 == 'value_a2'
assert values.b1 == 'value_b1'
assert values.b2 == 'value_b2'
assert leftovers == []
values, leftovers = full_parser.parse(full_parameters)
assert values.a1 == 'value_a1'
assert values.a2 == 'value_a2'
assert values.b1 == 'value_b1'
assert values.b2 == 'value_b2'
assert values.a == 'value_a'
assert values.b == 'value_b'
assert leftovers == []
def test_groups(self):
option_a = options.Option("-a", dest="a")
option_b = options.Option("-b", dest="b")
option_group_a = options.group("a")
option_group_b = options.group("b")
option_group_a.add_option(options.Option("--a1", dest="a1"), options.Option("--a2", dest="a2"))
option_group_b.add_option(options.Option("--b1", dest="b1"), options.Option("--b2", dest="b2"))
partial_parser = options.parser().interspersed_arguments(True).groups([option_group_a, option_group_b])
full_parser = partial_parser.options([option_a, option_b])
parameters = ["--a1", "value_a1", "--a2", "value_a2", "--b1", "value_b1", "--b2", "value_b2"]
full_parameters = parameters + ["-a", "value_a", "-b", "value_b"]
values, leftovers = partial_parser.parse(parameters)
assert values.a1 == "value_a1"
assert values.a2 == "value_a2"
assert values.b1 == "value_b1"
assert values.b2 == "value_b2"
assert leftovers == []
values, leftovers = full_parser.parse(full_parameters)
assert values.a1 == "value_a1"
assert values.a2 == "value_a2"
assert values.b1 == "value_b1"
assert values.b2 == "value_b2"
assert values.a == "value_a"
assert values.b == "value_b"
assert leftovers == []
def _construct_partial_parser(self):
"""
Construct an options parser containing only options added by __main__
or global help options registered by the application.
"""
values_copy = copy.deepcopy(self._option_values)
parser = (options.parser()
.interspersed_arguments(self._interspersed_args)
.options(self._main_options)
.usage(self._usage))
if hasattr(self._commands.get(self._command), Application.OPTIONS_ATTR):
if self._command is None:
command_group = options.new_group('When running with no command')
else:
command_group = options.new_group('For command %s' % self._command)
for option in getattr(self._commands[self._command], Application.OPTIONS_ATTR):
op = copy.deepcopy(option)
if not hasattr(values_copy, op.dest):
setattr(values_copy, op.dest, op.default if op.default != optparse.NO_DEFAULT else None)
Application.rewrite_help(op)
op.default = optparse.NO_DEFAULT
command_group.add_option(op)
return parser.groups([command_group]).values(values_copy)
else:
return parser.values(values_copy)
def _construct_partial_parser(self):
"""
Construct an options parser containing only options added by __main__
or global help options registered by the application.
"""
values_copy = copy.deepcopy(self._option_values)
parser = (options.parser().interspersed_arguments(
self._interspersed_args).options(self._main_options).usage(
self._usage))
if hasattr(self._commands.get(self._command),
Application.OPTIONS_ATTR):
if self._command is None:
command_group = options.new_group(
'When running with no command')
else:
command_group = options.new_group('For command %s' %
self._command)
for option in getattr(self._commands[self._command],
Application.OPTIONS_ATTR):
op = copy.deepcopy(option)
if not hasattr(values_copy, op.dest):
setattr(
values_copy, op.dest, op.default
if op.default != optparse.NO_DEFAULT else None)
Application.rewrite_help(op)
op.default = optparse.NO_DEFAULT
command_group.add_option(op)
return parser.groups([command_group]).values(values_copy)
else:
return parser.values(values_copy)
def test_multiple_option_inheritance(self):
option_a = options.Option('-a', dest='a')
option_b = options.Option('-b', dest='b')
values, leftovers = (options.parser().options([option_a]).options(
[option_b])).parse(['-a', 'value_a', '-b', 'value_b'])
assert values.a == 'value_a'
assert values.b == 'value_b'
def test_multiple_option_inheritance(self):
option_a = options.Option("-a", dest="a")
option_b = options.Option("-b", dest="b")
values, leftovers = (options.parser().options([option_a]).options([option_b])).parse(
["-a", "value_a", "-b", "value_b"]
)
assert values.a == "value_a"
assert values.b == "value_b"
def test_multiple_value_inheritance(self):
option_list = [options.Option("-a", dest="a"), options.Option("-b", dest="b")]
values_with_a, _ = options.parser().options(option_list).parse(["-a", "value_a"])
values_with_b, _ = options.parser().options(option_list).parse(["-b", "value_b"])
values, leftovers = (options.parser().options(option_list).values(values_with_a).values(values_with_b)).parse(
[]
)
assert values.a == "value_a"
assert values.b == "value_b"
# and parsed values overwrite
values, leftovers = (options.parser().options(option_list).values(values_with_a).values(values_with_b)).parse(
["-a", "new_value_a"]
)
assert values.a == "new_value_a"
assert values.b == "value_b"
def test_default_parsing(self):
option = options.Option('-m',
'--my_option',
default="specified",
dest='my_option')
values, leftovers = options.parser().options([option]).parse([])
assert hasattr(values, 'my_option')
assert leftovers == []
assert values.my_option == 'specified'
def test_multiple_value_inheritance(self):
option_list = [
options.Option('-a', dest='a'),
options.Option('-b', dest='b')
]
values_with_a, _ = options.parser().options(option_list).parse(
['-a', 'value_a'])
values_with_b, _ = options.parser().options(option_list).parse(
['-b', 'value_b'])
values, leftovers = (options.parser().options(option_list).values(
values_with_a).values(values_with_b)).parse([])
assert values.a == 'value_a'
assert values.b == 'value_b'
# and parsed values overwrite
values, leftovers = (options.parser().options(option_list).values(
values_with_a).values(values_with_b)).parse(['-a', 'new_value_a'])
assert values.a == 'new_value_a'
assert values.b == 'value_b'
def test_basic_parsing(self):
option = options.Option("-m", "--my_option", dest="my_option")
# w/o option
values, leftovers = options.parser().options([option]).parse([])
assert not hasattr(values, "my_option")
assert leftovers == []
# w/ option
values, leftovers = options.parser().options([option]).parse(["-m", "poop"])
assert values.my_option == "poop"
assert leftovers == []
# w/ long option
values, leftovers = options.parser().options([option]).parse(["--my_option", "plork"])
assert values.my_option == "plork"
assert leftovers == []
# w/ option and leftover
values, leftovers = options.parser().options([option]).parse(["--my_option", "plork", "hork"])
assert values.my_option == "plork"
assert leftovers == ["hork"]
def test_mutation_creates_new_parser(self):
parser1 = options.parser()
parser2 = parser1.interspersed_arguments(True)
parser3 = parser2.usage("foo")
assert parser1 is not parser2
assert parser2 is not parser3
assert parser1 is not parser3
assert parser1.interspersed_arguments() is False
assert parser1.usage() == ""
assert parser2.interspersed_arguments() is True
assert parser2.usage() == ""
assert parser3.interspersed_arguments() is True
assert parser3.usage() == "foo"
def test_mutation_creates_new_parser(self):
parser1 = options.parser()
parser2 = parser1.interspersed_arguments(True)
parser3 = parser2.usage("foo")
assert parser1 is not parser2
assert parser2 is not parser3
assert parser1 is not parser3
assert parser1.interspersed_arguments() is False
assert parser1.usage() == ""
assert parser2.interspersed_arguments() is True
assert parser2.usage() == ""
assert parser3.interspersed_arguments() is True
assert parser3.usage() == "foo"
def test_parsable(capsys):
parser = options.parser().options((
ClusterOption('--source_cluster', '-s', clusters=CLUSTER_LIST),
ClusterOption('--dest_cluster', clusters=CLUSTER_LIST),
ClusterOption('--cluster', cluster_provider=cluster_provider)))
values, _ = parser.parse(['--source_cluster=smf1-test', '--cluster=smf1-test'])
assert isinstance(values.source_cluster, Cluster)
assert isinstance(values.cluster, Cluster)
with pytest.raises(SystemExit):
parser.parse(['--source_cluster=borg'])
out, err = capsys.readouterr()
assert 'error: borg is not a valid cluster for the --source_cluster option.' in err
def _construct_partial_parser(self):
"""
Construct an options parser containing only options added by __main__
or global help options registered by the application.
"""
parser = (options.parser()
.interspersed_arguments(self._interspersed_args)
.options(self._main_options)
.values(self._option_values)
.usage(self._usage))
if hasattr(self._commands.get(self._command), Application.OPTIONS_ATTR):
return parser.groups([getattr(self._commands[self._command], Application.OPTIONS_ATTR)])
else:
return parser
def test_parsable(capsys):
parser = options.parser().options(
(ClusterOption('--source_cluster', '-s', clusters=CLUSTER_LIST),
ClusterOption('--dest_cluster', clusters=CLUSTER_LIST),
ClusterOption('--cluster', cluster_provider=cluster_provider)))
values, _ = parser.parse(
['--source_cluster=smf1-test', '--cluster=smf1-test'])
assert isinstance(values.source_cluster, Cluster)
assert isinstance(values.cluster, Cluster)
with pytest.raises(SystemExit):
parser.parse(['--source_cluster=borg'])
out, err = capsys.readouterr()
assert 'error: borg is not a valid cluster for the --source_cluster option.' in err
def test_parser_defaults(self):
parser = options.parser()
assert parser.interspersed_arguments() is False
assert parser.usage() == ""
def test_default_parsing(self):
option = options.Option("-m", "--my_option", default="specified", dest="my_option")
values, leftovers = options.parser().options([option]).parse([])
assert hasattr(values, "my_option")
assert leftovers == []
assert values.my_option == "specified"
def _main_parser(self):
return (options.parser().interspersed_arguments(self._interspersed_args)
.options(self._main_options)
.usage(self._usage))
def _main_parser(self):
return (options.parser().interspersed_arguments(
self._interspersed_args).options(self._main_options).usage(
self._usage))
def test_parser_defaults(self):
parser = options.parser()
assert parser.interspersed_arguments() is False
assert parser.usage() == ""
