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 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 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
class help_for: 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(myarg, otherarg, optval): pass col = Collection(mytask) self.tasked = col.to_contexts()[0] @raises(ValueError) def raises_ValueError_for_non_flag_values(self): self.vanilla.help_for('foo') def vanilla_no_helpstr(self): eq_(self.vanilla.help_for('--foo'), ("--foo=STRING", "")) def vanilla_with_helpstr(self): eq_(self.vanilla.help_for('--bar'), ("--bar=STRING", "bar the baz")) def task_driven_with_helpstr(self): eq_(self.tasked.help_for('--otherarg'), ("-o STRING, --otherarg=STRING", "other help")) # Yes, the next 3 tests are identical in form, but technically they # test different behaviors. HERPIN' AN' DERPIN' def task_driven_no_helpstr(self): eq_(self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "")) def short_form_before_long_form(self): eq_(self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "")) def equals_sign_for_long_form_only(self): eq_(self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "")) def kind_to_placeholder_map(self): # str=STRING, int=INT, etc etc skip() def shortflag_inputs_work_too(self): eq_(self.tasked.help_for('-m'), self.tasked.help_for('--myarg')) def optional_values_use_brackets(self): eq_(self.tasked.help_for('--optval'), ("-p [STRING], --optval[=STRING]", ""))
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 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 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 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 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 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 _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 setup(self): self.arg = Argument('--boolean') self.orig = Context( name='mytask', args=(self.arg,), aliases=('othername',) ) self.new = copy.deepcopy(self.orig)
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 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 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 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 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 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 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 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 represents_whether_all_positional_args_have_values(self): c = Context(name='foo', args=( Argument('arg1', positional=True), Argument('arg2', positional=False), Argument('arg3', positional=True), )) eq_(c.needs_positional_arg, True) c.positional_args[0].value = 'wat' eq_(c.needs_positional_arg, True) c.positional_args[1].value = 'hrm' eq_(c.needs_positional_arg, False)
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 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_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 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_initial_context(self): a = Argument('foo', kind=bool) eq_(a.value, 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 eq_(a.value, None) eq_(a2.value, True)
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]) eq_(mytask.positional_args, [pos1, pos2]) r = Parser([mytask]).parse_argv([ 'mytask', '--nonpos', 'wut', '--pos2', 'pos2val', 'pos1val', ])[0] eq_(r.args['pos1'].value, 'pos1val') eq_(r.args['pos2'].value, 'pos2val') eq_(r.args['nonpos'].value, 'wut')
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 setup(self): self.c = Context()
def setup(self): self.c = Context(args=( Argument('foo'), Argument(names=('bar', 'biz')), Argument('baz', attr_name='wat'), ))
class add_arg: def setup(self): self.c = Context() def can_take_Argument_instance(self): a = Argument(names=('foo', )) self.c.add_arg(a) assert self.c.args['foo'] is a def can_take_name_arg(self): self.c.add_arg('foo') assert 'foo' in self.c.args def can_take_kwargs_for_single_Argument(self): self.c.add_arg(names=('foo', 'bar')) assert 'foo' in self.c.args and 'bar' in self.c.args @raises(ValueError) def raises_ValueError_on_duplicate(self): self.c.add_arg(names=('foo', 'bar')) self.c.add_arg(name='bar') def adds_flaglike_name_to_dot_flags(self): "adds flaglike name to .flags" self.c.add_arg('foo') assert '--foo' in self.c.flags def adds_all_names_to_dot_flags(self): "adds all names to .flags" self.c.add_arg(names=('foo', 'bar')) assert '--foo' in self.c.flags assert '--bar' in self.c.flags def adds_true_bools_to_inverse_flags(self): self.c.add_arg(name='myflag', default=True, kind=bool) assert '--myflag' in self.c.flags assert '--no-myflag' in self.c.inverse_flags eq_(self.c.inverse_flags['--no-myflag'], '--myflag') def inverse_flags_works_right_with_task_driven_underscored_names(self): # Use a Task here instead of creating a raw argument, we're partly # testing Task.get_arguments()' transform of underscored names # here. Yes that makes this an integration test, but it's nice to # test it here at this level & not just in cli tests. @task def mytask(underscored_option=True): pass self.c.add_arg(mytask.get_arguments()[0]) eq_(self.c.inverse_flags['--no-underscored-option'], '--underscored-option') def turns_single_character_names_into_short_flags(self): self.c.add_arg('f') assert '-f' in self.c.flags assert '--f' not in self.c.flags def adds_positional_args_to_positional_args(self): self.c.add_arg(name='pos', positional=True) eq_(self.c.positional_args[0].name, 'pos') def positional_args_empty_when_none_given(self): eq_(len(self.c.positional_args), 0) def positional_args_filled_in_order(self): self.c.add_arg(name='pos1', positional=True) eq_(self.c.positional_args[0].name, 'pos1') self.c.add_arg(name='abc', positional=True) eq_(self.c.positional_args[1].name, 'abc') def positional_arg_modifications_affect_args_copy(self): self.c.add_arg(name='hrm', positional=True) eq_(self.c.args['hrm'].value, self.c.positional_args[0].value) self.c.positional_args[0].value = 17 eq_(self.c.args['hrm'].value, self.c.positional_args[0].value)
def _assert_order(self, name_tuples, expected_flag_order): ctx = Context(args=[Argument(names=x) for x in name_tuples]) return eq_( ctx.help_tuples(), [ctx.help_for(x) for x in expected_flag_order] )
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 _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 can_take_kwargs(self): c = Context() c.add_arg(names=('foo', 'bar')) assert c.has_arg('foo') and c.has_arg('bar')
def can_take_name_arg(self): c = Context() c.add_arg('foo') assert c.has_arg('foo')
def returns_True_if_flag_is_valid_arg(self): c = Context() c.add_arg(Argument(names=('foo',))) eq_(c.has_arg('foo'), True)
def raises_ValueError_on_duplicate(self): c = Context() c.add_arg(names=('foo', 'bar')) c.add_arg(name='bar')
def returns_Argument_for_given_name(self): c = Context() a = Argument(name='foo') c.add_arg(a) assert c.get_arg('foo') is a
def _assert_order(self, name_tuples, expected_flag_order): ctx = Context(args=map(lambda x: Argument(names=x), name_tuples)) return eq_(ctx.help_tuples(), map(ctx.help_for, expected_flag_order))
class add_arg: def setup(self): self.c = Context() def can_take_Argument_instance(self): a = Argument(names=('foo',)) self.c.add_arg(a) assert self.c.args['foo'] is a def can_take_name_arg(self): self.c.add_arg('foo') assert 'foo' in self.c.args def can_take_kwargs_for_single_Argument(self): self.c.add_arg(names=('foo', 'bar')) assert 'foo' in self.c.args and 'bar' in self.c.args @raises(ValueError) def raises_ValueError_on_duplicate(self): self.c.add_arg(names=('foo', 'bar')) self.c.add_arg(name='bar') def adds_flaglike_name_to_dot_flags(self): "adds flaglike name to .flags" self.c.add_arg('foo') assert '--foo' in self.c.flags def adds_all_names_to_dot_flags(self): "adds all names to .flags" self.c.add_arg(names=('foo', 'bar')) assert '--foo' in self.c.flags assert '--bar' in self.c.flags def turns_single_character_names_into_short_flags(self): self.c.add_arg('f') assert '-f' in self.c.flags assert '--f' not in self.c.flags def adds_positional_args_to_positional_args(self): self.c.add_arg(name='pos', positional=True) eq_(self.c.positional_args[0].name, 'pos') def positional_args_empty_when_none_given(self): eq_(len(self.c.positional_args), 0) def positional_args_filled_in_order(self): self.c.add_arg(name='pos1', positional=True) eq_(self.c.positional_args[0].name, 'pos1') self.c.add_arg(name='abc', positional=True) eq_(self.c.positional_args[1].name, 'abc') def positional_arg_modifications_affect_args_copy(self): self.c.add_arg(name='hrm', positional=True) eq_(self.c.args['hrm'].value, self.c.positional_args[0].value) self.c.positional_args[0].value = 17 eq_(self.c.args['hrm'].value, self.c.positional_args[0].value)
class help_for: 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 raises_ValueError_for_non_flag_values(self): with raises(ValueError): self.vanilla.help_for('foo') def vanilla_no_helpstr(self): assert self.vanilla.help_for('--foo') == ("--foo=STRING", "") def vanilla_with_helpstr(self): result = self.vanilla.help_for('--bar') assert result == ("--bar=STRING", "bar the baz") def task_driven_with_helpstr(self): result = self.tasked.help_for('--otherarg') assert result == ("-o STRING, --otherarg=STRING", "other help") # Yes, the next 3 tests are identical in form, but technically they # test different behaviors. HERPIN' AN' DERPIN' def task_driven_no_helpstr(self): result = self.tasked.help_for('--myarg') assert result == ("-m STRING, --myarg=STRING", "") def short_form_before_long_form(self): result = self.tasked.help_for('--myarg') assert result == ("-m STRING, --myarg=STRING", "") def equals_sign_for_long_form_only(self): result = self.tasked.help_for('--myarg') assert result == ("-m STRING, --myarg=STRING", "") def kind_to_placeholder_map(self): # Strings helpfor = self.tasked.help_for('--myarg') assert helpfor == ("-m STRING, --myarg=STRING", "") # Ints helpfor = self.tasked.help_for('--intval') assert helpfor == ("-i INT, --intval=INT", "") # TODO: others def shortflag_inputs_work_too(self): m = self.tasked.help_for('-m') myarg = self.tasked.help_for('--myarg') assert m == myarg def optional_values_use_brackets(self): result = self.tasked.help_for('--optval') assert result == ("-p [STRING], --optval[=STRING]", "") 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 true_default_args(self): c = Context(args=(Argument('truthy', kind=bool, default=True),)) assert c.help_for('--truthy') == ('--[no-]truthy', '')
def can_take_Argument_instance(self): c = Context() a = Argument(names=('foo',)) c.add_arg(a) assert c.get_arg('foo') is a
class add_arg: def setup(self): self.c = Context() def can_take_Argument_instance(self): a = Argument(names=('foo',)) self.c.add_arg(a) assert self.c.args['foo'] is a def can_take_name_arg(self): self.c.add_arg('foo') assert 'foo' in self.c.args def can_take_kwargs(self): self.c.add_arg(names=('foo', 'bar')) assert 'foo' in self.c.args and 'bar' in self.c.args @raises(ValueError) def raises_ValueError_on_duplicate(self): self.c.add_arg(names=('foo', 'bar')) self.c.add_arg(name='bar') def adds_flaglike_name_to_dot_flags(self): "adds flaglike name to .flags" self.c.add_arg('foo') assert '--foo' in self.c.flags def adds_all_names_to_dot_flags(self): "adds all names to .flags" self.c.add_arg(names=('foo', 'bar')) assert '--foo' in self.c.flags assert '--bar' in self.c.flags def turns_single_character_names_into_short_flags(self): self.c.add_arg('f') assert '-f' in self.c.flags assert '--f' not in self.c.flags
def may_give_arg_list_at_init_time(self): a1 = Argument('foo') a2 = Argument('bar') c = Context(name='name', args=(a1, a2)) assert c.get_arg('foo') is a1
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'),)) eq_(c.help_for('--i-have-underscores'), ('--i-have-underscores=STRING', 'yup'))
class add_arg: def setup(self): self.c = Context() def can_take_Argument_instance(self): a = Argument(names=('foo',)) self.c.add_arg(a) assert self.c.args['foo'] is a def can_take_name_arg(self): self.c.add_arg('foo') assert 'foo' in self.c.args def can_take_kwargs_for_single_Argument(self): self.c.add_arg(names=('foo', 'bar')) assert 'foo' in self.c.args and 'bar' in self.c.args def raises_ValueError_on_duplicate(self): self.c.add_arg(names=('foo', 'bar')) with raises(ValueError): self.c.add_arg(name='bar') def adds_flaglike_name_to_dot_flags(self): "adds flaglike name to .flags" self.c.add_arg('foo') assert '--foo' in self.c.flags def adds_all_names_to_dot_flags(self): "adds all names to .flags" self.c.add_arg(names=('foo', 'bar')) assert '--foo' in self.c.flags assert '--bar' in self.c.flags def adds_true_bools_to_inverse_flags(self): self.c.add_arg(name='myflag', default=True, kind=bool) assert '--myflag' in self.c.flags assert '--no-myflag' in self.c.inverse_flags assert self.c.inverse_flags['--no-myflag'] == '--myflag' def inverse_flags_works_right_with_task_driven_underscored_names(self): # Use a Task here instead of creating a raw argument, we're partly # testing Task.get_arguments()' transform of underscored names # here. Yes that makes this an integration test, but it's nice to # test it here at this level & not just in cli tests. @task def mytask(c, underscored_option=True): pass self.c.add_arg(mytask.get_arguments()[0]) flags = self.c.inverse_flags['--no-underscored-option'] assert flags == '--underscored-option' def turns_single_character_names_into_short_flags(self): self.c.add_arg('f') assert '-f' in self.c.flags assert '--f' not in self.c.flags def adds_positional_args_to_positional_args(self): self.c.add_arg(name='pos', positional=True) assert self.c.positional_args[0].name == 'pos' def positional_args_empty_when_none_given(self): assert len(self.c.positional_args) == 0 def positional_args_filled_in_order(self): self.c.add_arg(name='pos1', positional=True) assert self.c.positional_args[0].name == 'pos1' self.c.add_arg(name='abc', positional=True) assert self.c.positional_args[1].name == 'abc' def positional_arg_modifications_affect_args_copy(self): self.c.add_arg(name='hrm', positional=True) assert self.c.args['hrm'].value == self.c.positional_args[0].value self.c.positional_args[0].value = 17 assert self.c.args['hrm'].value == self.c.positional_args[0].value
def true_default_args(self): c = Context(args=(Argument("truthy", kind=bool, default=True),)) assert c.help_for("--truthy") == ("--[no-]truthy", "")
class help_for: 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'}) def mytask(myarg, otherarg): pass col = Collection(mytask) self.tasked = col.to_contexts()[0] @raises(ValueError) def raises_ValueError_for_non_flag_values(self): self.vanilla.help_for('foo') def vanilla_no_helpstr(self): eq_( self.vanilla.help_for('--foo'), ("--foo=STRING", "") ) def vanilla_with_helpstr(self): eq_( self.vanilla.help_for('--bar'), ("--bar=STRING", "bar the baz") ) def task_driven_with_helpstr(self): eq_( self.tasked.help_for('--otherarg'), ("-o STRING, --otherarg=STRING", "other help") ) # Yes, the next 3 tests are identical in form, but technically they # test different behaviors. HERPIN' AN' DERPIN' def task_driven_no_helpstr(self): eq_( self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "") ) def short_form_before_long_form(self): eq_( self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "") ) def equals_sign_for_long_form_only(self): eq_( self.tasked.help_for('--myarg'), ("-m STRING, --myarg=STRING", "") ) def kind_to_placeholder_map(self): # str=STRING, int=INT, etc etc skip() def shortflag_inputs_work_too(self): eq_(self.tasked.help_for('-m'), self.tasked.help_for('--myarg'))
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")