def unfilled_posargs(self): p = self._parser( ( Argument("foo", optional=True), Argument("bar", positional=True), ) ) self._test_for_ambiguity("--foo uhoh", p)
def setup(self): self.c = Context( args=( Argument("foo"), Argument(names=("bar", "biz")), Argument("baz", attr_name="wat"), ) )
def valid_argument_is_NOT_ambiguous(self): # The one exception that proves the rule? self._parser((Argument("foo", optional=True), Argument("bar"))) for form in ("--bar barval", "--bar=barval"): result = self._parse("--foo {}".format(form)) assert len(result) == 1 args = result[0].args assert args["foo"].value is True assert args["bar"].value == "barval"
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 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 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 represents_positional_args_missing_values(self): arg1 = Argument("arg1", positional=True) arg2 = Argument("arg2", positional=False) arg3 = Argument("arg3", positional=True) c = Context(name="foo", args=(arg1, arg2, arg3)) assert c.missing_positional_args == [arg1, arg3] c.positional_args[0].value = "wat" assert c.missing_positional_args == [arg3] c.positional_args[1].value = "hrm" assert c.missing_positional_args == []
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 no_ambiguity_if_option_val_already_given(self): p = self._parser( ( Argument("foo", optional=True), Argument("bar", kind=bool), ) ) # This should NOT raise a ParseError. result = self._parse("--foo hello --bar", p) assert result[0].args["foo"].value == "hello" assert result[0].args["bar"].value is True
def valid_flaglike_argument_is_NOT_ambiguous(self): # The OTHER exception that proves the rule? self._parser( ( Argument("foo", optional=True), Argument("bar", kind=bool), ) ) result = self._parse("--foo --bar") assert len(result) == 1 args = result[0].args assert args["foo"].value is True assert args["bar"].value is True
def setup(self): # Normal, non-task/collection related Context self.vanilla = Context( args=(Argument("foo"), Argument("bar", help="bar the baz")) ) # Task/Collection generated Context # (will expose flags n such) @task(help={"otherarg": "other help"}, optional=["optval"]) def mytask(c, myarg, otherarg, optval, intval=5): pass col = Collection(mytask) self.tasked = col.to_contexts()[0]
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 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 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 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 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 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 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 _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 list_kind_triggers_append_instead_of_overwrite(self): # TODO: when put this way it makes the API look pretty strange; # maybe a sign we should switch to explicit setter methods # (selected on kind, perhaps) instead of using an implicit setter a = Argument("mylist", kind=list) assert a.value == [] a.value = "val1" assert a.value == ["val1"] a.value = "val2" assert a.value == ["val1", "val2"]
def positional_args_can_still_be_given_as_flags(self): # AKA "positional args can come anywhere in the context" pos1 = Argument("pos1", positional=True) pos2 = Argument("pos2", positional=True) nonpos = Argument("nonpos", positional=False, default="lol") mytask = Context("mytask", args=[pos1, pos2, nonpos]) assert mytask.positional_args == [pos1, pos2] r = Parser([mytask]).parse_argv( [ "mytask", "--nonpos", "wut", "--pos2", "pos2val", "pos1val", ] )[0] assert r.args["pos1"].value == "pos1val" assert r.args["pos2"].value == "pos2val" assert r.args["nonpos"].value == "wut"
def incrementable_True_triggers_increment_of_default(self): a = Argument("verbose", kind=int, default=0, incrementable=True) assert a.value == 0 # NOTE: parser currently just goes "Argument.takes_value is false? # Gonna stuff True/False in there." So this looks pretty silly out # of context (as with list-types above.) a.value = True assert a.value == 1 for _ in range(4): a.value = True assert a.value == 5
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
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 can_take_Argument_instance(self): a = Argument(names=("foo",)) self.c.add_arg(a) assert self.c.args["foo"] is a
def args_show_as_repr(self): string = str(Context("bar", args=[Argument("arg1")])) assert ( string == "<parser/Context 'bar': {'arg1': <Argument: arg1>}>" ) # noqa
def _assert_order(self, name_tuples, expected_flag_order): c = Context(args=[Argument(names=x) for x in name_tuples]) expected = [c.help_for(x) for x in expected_flag_order] assert c.help_tuples() == expected
def true_default_args(self): c = Context(args=(Argument("truthy", kind=bool, default=True),)) assert c.help_for("--truthy") == ("--[no_]truthy", "")
def underscored_args(self): c = Context(args=(Argument("i_have_underscores", help="yup"),)) result = c.help_for("--i_have_underscores") assert result == ("--i_have_underscores=STRING", "yup")
def may_give_arg_list_at_init_time(self): a1 = Argument("foo") a2 = Argument("bar") c = Context(name="name", args=(a1, a2)) assert c.args["foo"] is a1