1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
from spec import Spec, eq_, skip, ok_, raises
from invoke.parser import Argument
class Argument_(Spec):
class init:
"__init__"
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 may_take_name_arg(self):
assert '-b' in Argument(name='-b').names
@raises(TypeError)
def must_get_at_least_one_name(self):
Argument()
def default_arg_is_name_not_names(self):
assert 'b' in Argument('b').names
def can_declare_positional(self):
eq_(Argument(name='foo', positional=True).positional, True)
def positional_is_False_by_default(self):
eq_(Argument(name='foo').positional, False)
def can_set_attr_name_to_control_name_attr(self):
a = Argument('foo', attr_name='bar')
eq_(a.name, 'bar') # not 'foo'
class string:
"__str__"
def shows_useful_info(self):
eq_(
str(Argument(names=('name', 'nick1', 'nick2'))),
"<Argument: {0} ({1})>".format('name', 'nick1, nick2')
)
def does_not_show_nickname_parens_if_no_nicknames(self):
eq_(
str(Argument('name')),
"<Argument: name>"
)
def shows_positionalness(self):
eq_(
str(Argument('name', positional=True)),
"<Argument: name*>"
)
class repr:
"__repr__"
def just_aliases_dunder_str(self):
a = Argument(names=('name', 'name2'))
eq_(str(a), repr(a))
class kind_kwarg:
"'kind' kwarg"
def is_optional(self):
Argument(name='a')
Argument(name='b', kind=int)
def defaults_to_str(self):
eq_(Argument('a').kind, str)
def non_bool_implies_value_needed(self):
assert Argument(name='a', kind=int).takes_value
def bool_implies_no_value_needed(self):
assert not Argument(name='a', kind=bool).takes_value
def bool_implies_default_False_not_None(self):
# Right now, parsing a bool flag not given results in None
# TODO: may want more nuance here -- False when a --no-XXX flag is
# given, True if --XXX, None if not seen?
# Only makes sense if we add automatic --no-XXX stuff (think
# ./configure)
skip()
@raises(ValueError)
def may_validate_on_set(self):
Argument('a', kind=int).value = 'five'
class names:
def returns_tuple_of_all_names(self):
eq_(Argument(names=('--foo', '-b')).names, ('--foo', '-b'))
eq_(Argument(name='--foo').names, ('--foo',))
def is_normalized_to_a_tuple(self):
ok_(isinstance(Argument(names=('a', 'b')).names, tuple))
class name:
def returns_first_name(self):
eq_(Argument(names=('a', 'b')).name, 'a')
class nicknames:
def returns_rest_of_names(self):
eq_(Argument(names=('a', 'b')).nicknames, ('b',))
class takes_value:
def True_by_default(self):
assert Argument(name='a').takes_value
def False_if_kind_is_bool(self):
assert not Argument(name='-b', kind=bool).takes_value
class value_set:
"value="
def available_as_dot_raw_value(self):
"available as .raw_value"
a = Argument('a')
a.value = 'foo'
eq_(a.raw_value, 'foo')
def untransformed_appears_as_dot_value(self):
"untransformed, appears as .value"
a = Argument('a', kind=str)
a.value = 'foo'
eq_(a.value, 'foo')
def transformed_appears_as_dot_value_with_original_as_raw_value(self):
"transformed, modified value is .value, original is .raw_value"
a = Argument('a', kind=int)
a.value = '5'
eq_(a.value, 5)
eq_(a.raw_value, '5')
class value:
def returns_default_if_not_set(self):
a = Argument('a', default=25)
eq_(a.value, 25)
class raw_value:
def is_None_when_no_value_was_actually_seen(self):
a = Argument('a', kind=int)
eq_(a.raw_value, None)
class set_value:
def casts_by_default(self):
a = Argument('a', kind=int)
a.set_value('5')
eq_(a.value, 5)
def allows_setting_value_without_casting(self):
a = Argument('a', kind=int)
a.set_value('5', cast=False)
eq_(a.value, '5')
|
