def list_kind_test_for_empty_list_value(self): arg = Argument("a", kind=list) assert not arg.got_value arg.value = "append-me" assert arg.got_value
def _compare(self, argname, invoke, value): c = Context("mytask", args=(Argument(argname, kind=str),)) r = Parser((c,)).parse_argv(["mytask", invoke]) assert r[0].args[argname].value == value
def task_name(self): # mytask --foo myothertask c1 = Context("mytask", args=(Argument("foo", optional=True),)) c2 = Context("othertask") p = Parser([c1, c2]) self._test_for_ambiguity("--foo othertask", p)
def returned_context_member_arguments_contain_given_values(self): c = Context("mytask", args=(Argument("boolean", kind=bool),)) result = Parser((c,)).parse_argv(["mytask", "--boolean"]) assert result[0].args["boolean"].value is True
def setup(self): self.p = Parser([Context(name="foo", args=[Argument("bar")])])
def non_bool_implies_value_needed(self): assert Argument(name="a", kind=int).takes_value assert Argument(name="b", kind=str).takes_value assert Argument(name="c", kind=list).takes_value
def may_take_names_list(self): names = ("--foo", "-f") a = Argument(names=names) # herp a derp for name in names: assert name in a.names
def positional_is_False_by_default(self): assert Argument(name="foo").positional is False
def can_set_attr_name_to_control_name_attr(self): a = Argument("foo", attr_name="bar") assert a.name == "bar" # not 'foo'
def default_arg_is_name_not_names(self): assert "b" in Argument("b").names
def can_declare_positional(self): assert Argument(name="foo", positional=True).positional is True
def allows_setting_value_without_casting(self): a = Argument("a", kind=int) a.set_value("5", cast=False) assert a.value == "5"
def casts_by_default(self): a = Argument("a", kind=int) a.set_value("5") assert a.value == 5
def must_get_at_least_one_name(self): with raises(TypeError): Argument()
def is_optional(self): Argument(name="a") Argument(name="b", kind=int)
def shows_useful_info(self): arg = Argument(names=("name", "nick1", "nick2")) expected = "<Argument: {} ({})>".format("name", "nick1, nick2") assert repr(arg) == expected
def defaults_to_str(self): assert Argument("a").kind == str
def does_not_show_nickname_parens_if_no_nicknames(self): assert repr(Argument("name")) == "<Argument: name>"
def bool_implies_no_value_needed(self): assert not Argument(name="a", kind=bool).takes_value
def shows_positionalness(self): arg = Argument("name", positional=True) assert repr(arg) == "<Argument: name *>"
def may_validate_on_set(self): with raises(ValueError): Argument("a", kind=int).value = "five"
def shows_optionalness(self): arg = Argument("name", optional=True) assert repr(arg) == "<Argument: name ?>"
def inverse_bools_get_set_correctly(self): arg = Argument("myarg", kind=bool, default=True) c = Context("mytask", args=(arg,)) r = Parser((c,)).parse_argv(["mytask", "--no_myarg"]) assert r[0].args["myarg"].value is False
def positionalness_and_optionalness_stick_together(self): # TODO: but do these even make sense on the same argument? For now, # best to have a nonsensical test than a missing one... arg = Argument("name", optional=True, positional=True) assert repr(arg) == "<Argument: name *?>"
def _basic(self): arg = Argument("pos", positional=True) mytask = Context(name="mytask", args=[arg]) return Parser(contexts=[mytask])
def shows_kind_if_not_str(self): assert repr(Argument("age", kind=int)) == "<Argument: age [int]>"
def invalid_flaglike_value_is_stored_as_value(self): self._parser((Argument("foo", optional=True),)) result = self._parse("--foo --bar") assert result[0].args["foo"].value == "--bar"
def all_the_things_together(self): arg = Argument(names=("meh", "m"), kind=int, optional=True, positional=True) assert repr(arg) == "<Argument: meh (m) [int] *?>"
def _parse(self, *args): c = Context("mytask", args=(Argument("mylist", kind=list),)) argv = ["mytask"] + list(args) return Parser([c]).parse_argv(argv)[0].args.mylist.value
def non_list_kind_tests_for_None_value(self): arg = Argument("a") assert not arg.got_value arg.value = "something" assert arg.got_value