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