def task_args_work_correctly(self): task1 = Context("mytask", args=(Argument("meh"),)) result = Parser((task1,)).parse_argv( ["mytask", "--meh", "mehval1", "mytask", "--meh", "mehval2"] ) assert result[0].args.meh.value == "mehval1" assert result[1].args.meh.value == "mehval2"
def always_includes_initial_context_if_one_was_given(self): # Even if no core/initial flags were seen t1 = Context('t1') init = Context() result = Parser((t1, ), initial=init).parse_argv(['t1']) eq_(result[0].name, None) eq_(result[1].name, 't1')
def _parser(self, arguments=None): if arguments is None: arguments = (Argument(names=('foo', 'f'), optional=True, default='mydefault'), ) self.context = Context('mytask', args=arguments) return Parser([self.context])
def iterables_work_correctly_outside_a_vacuum(self): # Undetected bug where I was primarily focused on the -vvv use # case...'normal' incrementables never left 'waiting for value' # state in the parser! so _subsequent_ task names & such never got # parsed right, always got appended to the list. c = Context("mytask", args=[Argument("mylist", kind=list)]) c2 = Context("othertask") argv = [ "mytask", "--mylist", "val", "--mylist", "val2", "othertask", ] result = Parser([c, c2]).parse_argv(argv) # When bug present, result only has one context (for 'mytask') and # its 'mylist' consists of ['val', 'val2', 'othertask']. (the # middle '--mylist' was handled semi-correctly.) mylist = result[0].args.mylist.value assert mylist == ["val", "val2"] contexts = len(result) err = "Got {} parse context results instead of 2!".format(contexts) assert contexts == 2, err assert result[1].name == "othertask"
def task_args_work_correctly(self): task1 = Context('mytask', args=(Argument('meh'),)) result = Parser((task1,)).parse_argv( ['mytask', '--meh', 'mehval1', 'mytask', '--meh', 'mehval2'] ) eq_(result[0].args.meh.value, 'mehval1') eq_(result[1].args.meh.value, 'mehval2')
def value_requiring_core_flags_also_work_correctly(self): "value-requiring core flags also work correctly" initial = Context(args=[Argument("hide")]) task1 = Context("mytask") parser = Parser(initial=initial, contexts=[task1]) result = parser.parse_argv(["mytask", "--hide", "both"]) assert result[0].args.hide.value == "both"
def parses_sys_argv_style_list_of_strings(self): "parses sys.argv-style list of strings" # Doesn't-blow-up tests FTL mytask = Context(name="mytask") mytask.add_arg("arg") p = Parser(contexts=[mytask]) p.parse_argv(["mytask", "--arg", "value"])
def arguments_which_take_values_get_defaults_overridden_correctly(self): # noqa args = (Argument('arg', kind=str), Argument('arg2', kind=int)) c = Context('mytask', args=args) argv = ['mytask', '--arg', 'myval', '--arg2', '25'] result = Parser((c,)).parse_argv(argv) eq_(result[0].args['arg'].value, 'myval') eq_(result[0].args['arg2'].value, 25)
def parses_sys_argv_style_list_of_strings(self): "parses sys.argv-style list of strings" # Doesn't-blow-up tests FTL mytask = Context(name='mytask') mytask.add_arg('arg') p = Parser(contexts=[mytask]) p.parse_argv(['mytask', '--arg', 'value'])
def always_includes_initial_context_if_one_was_given(self): # Even if no core/initial flags were seen t1 = Context("t1") init = Context() result = Parser((t1,), initial=init).parse_argv(["t1"]) assert result[0].name is None assert result[1].name == "t1"
def task_has_no_help_shows_per_task_help(self): task1 = Context('mytask') init = Context(args=[Argument('help', optional=True)]) parser = Parser(initial=init, contexts=[task1]) result = parser.parse_argv(['mytask', '--help']) eq_(len(result), 2) eq_(result[0].args.help.value, 'mytask') ok_('help' not in result[1].args)
def handles_multiple_boolean_flags_per_context(self): c = Context('mytask', args=(Argument('foo', kind=bool), Argument('bar', kind=bool))) r = Parser([c]).parse_argv(['mytask', '--foo', '--bar']) a = r[0].args eq_(a.foo.value, True) eq_(a.bar.value, True)
def arguments_which_take_values_get_defaults_overridden_correctly( self): # noqa args = (Argument("arg", kind=str), Argument("arg2", kind=int)) c = Context("mytask", args=args) argv = ["mytask", "--arg", "myval", "--arg2", "25"] result = Parser((c, )).parse_argv(argv) assert result[0].args["arg"].value == "myval" assert result[0].args["arg2"].value == 25
def _parser(self, arguments=None): if arguments is None: arguments = (Argument(names=("foo", "f"), optional=True, default="mydefault"), ) self.context = Context("mytask", args=arguments) self.parser = Parser([self.context]) return self.parser
def by_itself_base_case(self): task1 = Context("mytask") init = Context(args=[Argument("help", optional=True)]) parser = Parser(initial=init, contexts=[task1]) result = parser.parse_argv(["mytask", "--help"]) assert len(result) == 2 assert result[0].args.help.value == "mytask" assert "help" not in result[1].args
def returned_arguments_not_given_contain_default_values(self): # I.e. a Context with args A and B, invoked with no mention of B, # should result in B existing in the result, with its default value # intact, and not e.g. None, or the arg not existing. a = Argument("name", kind=str) b = Argument("age", default=7) c = Context("mytask", args=(a, b)) Parser((c,)).parse_argv(["mytask", "--name", "blah"]) assert c.args["age"].value == 7
def other_tokens_afterwards_raise_parse_errors(self): # NOTE: this is because of the special-casing where we supply # the task name as the value when the flag is literally named # "help". task1 = Context("mytask") init = Context(args=[Argument("help", optional=True)]) parser = Parser(initial=init, contexts=[task1]) with raises(ParseError, match=r".*foobar.*"): parser.parse_argv(["mytask", "--help", "foobar"])
def task_has_no_h_shortflag_shows_per_task_help(self): task1 = Context("mytask") arg = Argument(names=("help", "h"), optional=True) init = Context(args=[arg]) parser = Parser(initial=init, contexts=[task1]) result = parser.parse_argv(["mytask", "-h"]) assert len(result) == 2 assert result[0].args.help.value == "mytask" assert "help" not in result[1].args
def core_flags_work_normally_when_no_conflict(self): # Initial parse context with an --echo, plus a no-args task initial = Context(args=[self._echo()]) task1 = Context("mytask") parser = Parser(initial=initial, contexts=[task1]) # Call with --echo in the per-task context, expect the core # context got updated (vs an error) result = parser.parse_argv(["mytask", "--echo"]) assert result[0].args.echo.value is True
def task_has_no_h_shortflag_shows_per_task_help(self): task1 = Context('mytask') arg = Argument(names=('help', 'h'), optional=True) init = Context(args=[arg]) parser = Parser(initial=init, contexts=[task1]) result = parser.parse_argv(['mytask', '-h']) eq_(len(result), 2) eq_(result[0].args.help.value, 'mytask') ok_('help' not in result[1].args)
def returned_arguments_not_given_contain_default_values(self): # I.e. a Context with args A and B, invoked with no mention of B, # should result in B existing in the result, with its default value # intact, and not e.g. None, or the arg not existing. a = Argument('name', kind=str) b = Argument('age', default=7) c = Context('mytask', args=(a, b)) Parser((c, )).parse_argv(['mytask', '--name', 'blah']) eq_(c.args['age'].value, 7)
def handles_multiple_boolean_flags_per_context(self): c = Context( "mytask", args=(Argument("foo", kind=bool), Argument("bar", kind=bool)), ) r = Parser([c]).parse_argv(["mytask", "--foo", "--bar"]) a = r[0].args assert a.foo.value is True assert a.bar.value is True
def when_conflict_per_task_args_win_out(self): # Initial parse context with an --echo, plus task w/ same initial = Context(args=[self._echo()]) task1 = Context("mytask", args=[self._echo()]) parser = Parser(initial=initial, contexts=[task1]) # Call with --echo in the per-task context, expect the task # context got updated, and not core. result = parser.parse_argv(["mytask", "--echo"]) assert result[0].args.echo.value is False assert result[1].args.echo.value is True
def positional_args_eat_otherwise_valid_context_names(self): mytask = Context('mytask', args=[ Argument('pos', positional=True), Argument('nonpos', default='default') ]) Context('lolwut') result = Parser([mytask]).parse_argv(['mytask', 'lolwut']) r = result[0] eq_(r.args['pos'].value, 'lolwut') eq_(r.args['nonpos'].value, 'default') eq_(len(result), 1) # Not 2
def omitted_positional_args_raises_ParseError(self): try: arg = Argument("pos", positional=True) arg2 = Argument("morepos", positional=True) mytask = Context(name="mytask", args=[arg, arg2]) Parser(contexts=[mytask]).parse_argv(["mytask"]) except ParseError as e: expected = "'mytask' did not receive required positional arguments: 'pos', 'morepos'" # noqa assert str(e) == expected else: assert False, "Did not raise ParseError!"
def core_bool_but_per_task_string(self): # Initial parse context with bool --hide, and a task with a # regular (string) --hide initial = Context( args=[Argument("hide", kind=bool, default=False)]) task1 = Context("mytask", args=[Argument("hide")]) parser = Parser(initial=initial, contexts=[task1]) # Expect that, because the task's version wins, we're able to # call it with a value. (If there were weird bugs where the # core flag informed the parsing, this would fail.) result = parser.parse_argv(["mytask", "--hide", "both"]) assert result[0].args.hide.value is False assert result[1].args.hide.value == "both"
def clones_noninitial_contexts(self): a = Argument('foo') eq_(a.value, None) c = Context(name='mytask', args=(a, )) p = Parser(contexts=(c, )) assert p.contexts['mytask'] is c r = p.parse_argv(['mytask', '--foo', 'val']) assert p.contexts['mytask'] is c c2 = r[0] assert c2 is not c a2 = c2.args['foo'] assert a2 is not a eq_(a.value, None) eq_(a2.value, 'val')
def positional_args_eat_otherwise_valid_context_names(self): mytask = Context( "mytask", args=[ Argument("pos", positional=True), Argument("nonpos", default="default"), ], ) Context("lolwut") result = Parser([mytask]).parse_argv(["mytask", "lolwut"]) r = result[0] assert r.args["pos"].value == "lolwut" assert r.args["nonpos"].value == "default" assert len(result) == 1 # Not 2
def clones_noninitial_contexts(self): a = Argument("foo") assert a.value is None c = Context(name="mytask", args=(a,)) p = Parser(contexts=(c,)) assert p.contexts["mytask"] is c r = p.parse_argv(["mytask", "--foo", "val"]) assert p.contexts["mytask"] is c c2 = r[0] assert c2 is not c a2 = c2.args["foo"] assert a2 is not a assert a.value is None assert a2.value == "val"
def clones_initial_context(self): a = Argument("foo", kind=bool) assert a.value is None c = Context(args=(a,)) p = Parser(initial=c) assert p.initial is c r = p.parse_argv(["--foo"]) assert p.initial is c c2 = r[0] assert c2 is not c a2 = c2.args["foo"] assert a2 is not a assert a.value is None assert a2.value is True