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_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))