def test_valid_int(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.StoreIntAction)
for i in [0, 1, 42, -64]:
args = parser.parse_args(['--foo', six.text_type(i)])
self.assertEqual(args.foo, i)
def test_default_value(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.ToggleFalseAction)
args = parser.parse_args([])
self.assertTrue(args.foo)
def test_store_false(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.StoreFalseAction)
args = parser.parse_args(['--foo'])
self.assertFalse(args.foo)
def test_with_no_arg(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.ToggleFalseAction)
args = parser.parse_args(['--foo'])
self.assertFalse(args.foo)
def test_suppressed_default_value(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.UnsupportedAction)
args = parser.parse_args([])
self.assertFalse(hasattr(args, 'foo'))
def test_store_const(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.StoreAction, const='bar')
args = parser.parse_args(['--foo'])
self.assertEqual(args.foo, 'bar')
def test_store_value_multiple_destinations(self):
parser = ArgumentParser()
parser.add_argument('--foo',
dests=['foo', 'bar'],
action=actions.StoreAction)
args = parser.parse_args(['--foo', 'baz'])
self.assertEqual(args.foo, 'baz')
self.assertEqual(args.bar, 'baz')
def test_parse_known_args_adds_defaults_to_dests(self):
parser = ArgumentParser()
parser.add_argument('--foo',
action=actions.StoreAction,
dests=['foo', 'bar'],
default='FooBar')
# parse_args calls parse_known_args under the hood
args = parser.parse_args([])
self.assertEqual(args.foo, 'FooBar')
self.assertEqual(args.bar, 'FooBar')
def test_custom_call_func(self):
def test_func(action, parser, namespace, values, option_string=None):
for dest in action.dests:
setattr(namespace, dest, values)
parser = ArgumentParser()
parser.add_argument('--foo',
action=actions.CustomCallAction,
call_func=test_func,
nargs=Nargs.SINGLE)
args = parser.parse_args(['--foo', 'boo'])
self.assertEqual(args.foo, 'boo')
def test_custom_error_message(self):
message = 'custom error message'
parser = ArgumentParser()
action = parser.add_argument('--foo',
action=actions.UnsupportedAction,
message=message)
self.assertEqual(action.message, message)
with utils.redirect_stderr() as stderr, self.assertRaises(SystemExit):
parser.parse_args(['--foo'])
self.assertIn(message, stderr)
def test_in_group(self):
builder = ArgumentParser.builder()
self.assertEqual(builder._current_group, builder._parser)
group = builder.in_group('First Group')
self.assertEqual(group, builder._current_group)
self.assertNotEqual(group, builder._parser)
def test_argument_group(self):
builder = ArgumentParser.builder()
with builder.argument_group('First Group') as group:
self.assertEqual(builder._current_group, group)
self.assertIsInstance(group, _ArgumentGroup)
self.assertEqual(builder._current_group, builder._parser)
def test_mutually_exclusive_group(self):
builder = ArgumentParser.builder()
with builder.mutually_exclusive_group(required=True) as group:
self.assertEqual(builder._current_group, group)
self.assertIsInstance(group, _MutuallyExclusiveGroup)
self.assertTrue(group.required)
self.assertEqual(builder._current_group, builder._parser)
def test_set_defaults(self):
builder = ArgumentParser.builder()
builder.set_defaults(foo=True, bar=False, baz=[])
builder.set_defaults('qux', 'Lorem ipsum set dolor')
self.assertEqual(builder._defaults, {
'foo': True,
'bar': False,
'baz': [],
'qux': 'Lorem ipsum set dolor',
})
def test_invalid_int(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.StoreIntAction)
for i in [0.0, True, 'bar']:
with utils.quiet_output(), self.assertRaises(SystemExit):
parser.parse_args(['--foo', six.text_type(i)])
def test_last_wins(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.ToggleFalseAction)
args = parser.parse_args(['--foo=TRUE', '--foo', 'FALSE'])
self.assertTrue(args.foo)
args = parser.parse_args(['--foo=FALSE', '--foo'])
self.assertFalse(args.foo)
args = parser.parse_args(['--foo=FALSE', '--foo', 'TRUE'])
self.assertFalse(args.foo)
def test_with_optional_true_arg(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.ToggleFalseAction)
for value in BoolType.TRUE_VALUES:
args = parser.parse_args(['--foo', str(value)])
self.assertFalse(args.foo)
args = parser.parse_args(['--foo={}'.format(value)])
self.assertFalse(args.foo)
def test_with_optional_false_arg(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.ToggleFalseAction)
for value in BoolType.FALSE_VALUES:
args = parser.parse_args(['--foo', six.text_type(value)])
self.assertTrue(args.foo)
args = parser.parse_args(['--foo={}'.format(value)])
self.assertTrue(args.foo)
def test_add_positional(self):
# Setup builder and DSL
builder = ArgumentParser.builder()
positional = builder.add_positional
store = builder.actions.store
store_int = builder.actions.store_int
# Create test parser
positional('foo', store)
positional('bar', store_int(['bar', 'baz']))
parser = builder.build()
args = parser.parse_args(['Foo', '1'])
self.assertEqual(args.foo, 'Foo')
self.assertEqual(args.bar, 1)
self.assertEqual(args.baz, 1)
def test_choices(self):
parser = ArgumentParser()
action = parser.add_argument('--foo',
action=actions.StoreAction,
choices=['bar', 'baz'])
self.assertEqual(action.nargs, Nargs.OPTIONAL)
with utils.quiet_output(), self.assertRaises(SystemExit):
parser.parse_args(['--foo', 'qux'])
args = parser.parse_args(['--foo', 'bar'])
self.assertEqual(args.foo, 'bar')
def test_add_option(self):
# Setup builder and DSL
builder = ArgumentParser.builder()
option = builder.add_option
append = builder.actions.append
store_true = builder.actions.store_true
toggle_false = builder.actions.toggle_false
unsupported = builder.actions.unsupported
# Create test parser
option('--foo', append)
option('--bar', store_true(['bar', 'foobar']))
option('--baz', toggle_false)
option('--qux', unsupported)
parser = builder.build()
args = parser.parse_args([])
self.assertEqual(args.foo, [])
self.assertFalse(args.bar)
self.assertFalse(args.foobar)
self.assertTrue(args.baz)
self.assertFalse(hasattr(args, 'qux'))
args = parser.parse_args(['--foo', 'Foo'])
self.assertEqual(args.foo, ['Foo'])
args = parser.parse_args(['--bar'])
self.assertTrue(args.bar)
self.assertTrue(args.foobar)
args = parser.parse_args(['--baz', '--baz=FALSE'])
self.assertTrue(args.baz)
with utils.quiet_output(), self.assertRaises(SystemExit):
parser.parse_args(['--qux'])
def test_builder(self):
builder = ArgumentParser.builder(usage='Totally useless help message')
self.assertIsInstance(builder._parser, ArgumentParser)
self.assertEqual(builder._parser.usage, 'Totally useless help message')
def test_append(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.AppendAction)
args = parser.parse_args(['--foo', 'bar', '--foo', 'baz'])
self.assertEqual(args.foo, ['bar', 'baz'])
def test_default_value(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.AppendAction)
args = parser.parse_args([])
self.assertEqual(args.foo, [])
def test_raises_parser_error(self):
parser = ArgumentParser()
parser.add_argument('--foo', action=actions.UnsupportedAction)
with utils.quiet_output(), self.assertRaises(SystemExit):
parser.parse_args(['--foo'])
def test_build(self):
builder = ArgumentParser.builder()
self.assertEqual(builder._parser, builder.build())
def test_to_builder(self):
parser = ArgumentParser()
builder = parser.to_builder()
self.assertEqual(parser, builder._parser)
