def test_init_options(self):
self.initialize_options()
definition = InputDefinition()
self.assertEqual([], definition.get_options())
definition = InputDefinition([self.foo, self.bar])
self.assertEqual([self.foo, self.bar], definition.get_options())
def provider_invalid_input(self):
return [
([('foo', 'bar')], InputDefinition([InputArgument('name')]),
'The "foo" argument does not exist.'),
(['--foo'],
InputDefinition([
InputOption('foo', 'f', InputOption.VALUE_REQUIRED)
]), 'The "--foo" option requires a value.'),
([('--foo', 'foo')], InputDefinition(),
'The "--foo" option does not exist.'),
([('-f', 'foo')], InputDefinition(),
'The "-f" option does not exist.'),
]
def test_get_synopsis(self):
definition = InputDefinition([InputOption('foo')])
self.assertEqual('[--foo]', definition.get_synopsis())
definition = InputDefinition([InputOption('foo', 'f')])
self.assertEqual('[-f|--foo]', definition.get_synopsis())
definition = InputDefinition(
[InputOption('foo', 'f', InputOption.VALUE_REQUIRED)])
self.assertEqual('[-f|--foo="..."]', definition.get_synopsis())
definition = InputDefinition(
[InputOption('foo', 'f', InputOption.VALUE_OPTIONAL)])
self.assertEqual('[-f|--foo[="..."]]', definition.get_synopsis())
definition = InputDefinition([InputArgument('foo')])
self.assertEqual('[foo]', definition.get_synopsis())
definition = InputDefinition(
[InputArgument('foo', InputArgument.REQUIRED)])
self.assertEqual('foo', definition.get_synopsis())
definition = InputDefinition(
[InputArgument('foo', InputArgument.IS_LIST)])
self.assertEqual('[foo1] ... [fooN]', definition.get_synopsis())
definition = InputDefinition([
InputArgument('foo',
InputArgument.REQUIRED | InputArgument.IS_LIST)
])
self.assertEqual('foo1 ... [fooN]', definition.get_synopsis())
def get_input_definitions(cls):
return {
'input_definition_1':
InputDefinition(),
'input_definition_2':
InputDefinition(
[InputArgument('argument_name', InputArgument.REQUIRED)]),
'input_definition_3':
InputDefinition(
[InputOption('option_name', 'o', InputOption.VALUE_NONE)]),
'input_definition_4':
InputDefinition([
InputArgument('argument_name', InputArgument.REQUIRED),
InputOption('option_name', 'o', InputOption.VALUE_NONE)
])
}
def test_parse_empty_string_argument(self):
input_ = ArgvInput(['cli.py', '-f', 'bar', ''])
input_.bind(InputDefinition([
InputArgument('empty'),
InputOption('foo', 'f', InputOption.VALUE_OPTIONAL)
]))
self.assertEqual({'empty': ''}, input_.get_arguments())
def test_get_invalid_option(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertRaisesRegexp(Exception,
'The "--bar" option does not exist.',
definition.get_option, 'bar')
def test_get_options_defaults(self):
definition = InputDefinition([
InputOption('foo1', None, InputOption.VALUE_NONE),
InputOption('foo2', None, InputOption.VALUE_REQUIRED),
InputOption('foo3', None, InputOption.VALUE_REQUIRED, '',
'default'),
InputOption('foo4', None, InputOption.VALUE_OPTIONAL),
InputOption('foo5', None, InputOption.VALUE_OPTIONAL, '',
'default'),
InputOption('foo6', None, InputOption.VALUE_OPTIONAL
| InputOption.VALUE_IS_LIST),
InputOption('foo7', None,
InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST,
'', [1, 2])
])
defaults = {
'foo1': False,
'foo2': None,
'foo3': 'default',
'foo4': None,
'foo5': 'default',
'foo6': [],
'foo7': [1, 2]
}
self.assertEqual(defaults, definition.get_option_defaults())
def test_set_options_clears_options(self):
self.initialize_options()
definition = InputDefinition([self.foo])
definition.set_options([self.bar])
self.assertRaisesRegexp(Exception, 'The "-f" option does not exist.',
definition.get_option_for_shortcut, 'f')
def test_get_invalid_argument(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_arguments([self.foo])
self.assertRaises(Exception, 'The "bar" argument does not exist.',
definition.get_argument, 'bar')
def test_required_argument_cannot_follow_an_optional_one(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_argument(self.foo)
self.assertRaisesRegexp(
Exception, 'Cannot add a required argument after an optional one.',
definition.add_argument, self.foo2)
def test_add_duplicate_shortcut_option(self):
self.initialize_options()
definition = InputDefinition()
definition.add_option(self.foo)
self.assertRaisesRegexp(Exception,
'An option with shortcut "f" already exists.',
definition.add_option, self.foo1)
def test_add_duplicate_option(self):
self.initialize_options()
definition = InputDefinition()
definition.add_option(self.foo)
self.assertRaisesRegexp(Exception,
'An option named "foo" already exists.',
definition.add_option, self.foo2)
def test_arguments_must_have_different_names(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_argument(self.foo)
self.assertRaisesRegexp(Exception,
'An argument with name "foo" already exists.',
definition.add_argument, self.foo1)
def test_add_argument(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_argument(self.foo)
self.assertEqual([self.foo], definition.get_arguments())
definition.add_argument(self.bar)
self.assertEqual([self.foo, self.bar], definition.get_arguments())
def test_set_arguments(self):
self.initialize_arguments()
definition = InputDefinition()
definition.set_arguments([self.foo])
self.assertEqual([self.foo], definition.get_arguments())
definition.set_arguments([self.bar])
self.assertEqual([self.bar], definition.get_arguments())
def test_has_argument(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_arguments([self.foo])
self.assertTrue(definition.has_argument('foo'))
self.assertFalse(definition.has_argument('bar'))
def test_argument_count(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_argument(self.foo2)
self.assertEqual(1, definition.get_argument_count())
definition.add_argument(self.foo)
self.assertEqual(2, definition.get_argument_count())
def test_parse_list_option(self):
input_ = ArgvInput(['cli.py', '--name=foo', '--name=bar', '--name=baz'])
input_.bind(
InputDefinition([
InputOption('name', None, InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST)
])
)
self.assertEqual(
{'name': ['foo', 'bar', 'baz']},
input_.get_options()
)
input_ = ArgvInput(['cli.py', '--name', 'foo', '--name', 'bar', '--name', 'baz'])
input_.bind(
InputDefinition([
InputOption('name', None, InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST)
])
)
self.assertEqual(
{'name': ['foo', 'bar', 'baz']},
input_.get_options()
)
input_ = ArgvInput(['cli.py', '--name=foo', '--name=bar', '--name='])
input_.bind(
InputDefinition([
InputOption('name', None, InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST)
])
)
self.assertEqual(
{'name': ['foo', 'bar', None]},
input_.get_options()
)
input_ = ArgvInput(['cli.py', '--name', 'foo', '--name', 'bar', '--name', '--another-option'])
input_.bind(
InputDefinition([
InputOption('name', None, InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST),
InputOption('another-option', None, InputOption.VALUE_NONE)
])
)
self.assertEqual(
{'name': ['foo', 'bar', None], 'another-option': True},
input_.get_options()
)
def test_negative_number_after_double_dash(self):
input_ = ArgvInput(['cli.py', '--', '-1'])
input_.bind(
InputDefinition([
InputArgument('number')
])
)
self.assertEqual({'number': '-1'}, input_.get_arguments())
input_ = ArgvInput(['cli.py', '-f', 'bar', '--', '-1'])
input_.bind(
InputDefinition([
InputArgument('number'),
InputOption('foo', 'f', InputOption.VALUE_OPTIONAL)
])
)
self.assertEqual({'foo': 'bar'}, input_.get_options())
self.assertEqual({'number': '-1'}, input_.get_arguments())
def test_list_argument_has_to_be_last(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_argument(InputArgument('foolist',
InputArgument.IS_LIST))
self.assertRaisesRegexp(
Exception, 'Cannot add an argument after a list argument.',
definition.add_argument, InputArgument('anotherbar'))
def test_get_argument_default(self):
definition = InputDefinition([
InputArgument('foo1', InputArgument.OPTIONAL),
InputArgument('foo2', InputArgument.OPTIONAL, '', 'default'),
InputArgument('foo3', InputArgument.OPTIONAL | InputArgument.IS_LIST),
])
self.assertEqual(
{
'foo1': None,
'foo2': 'default',
'foo3': []
},
definition.get_argument_defaults()
)
definition = InputDefinition([
InputArgument('foo4', InputArgument.OPTIONAL | InputArgument.IS_LIST, '', [1, 2])
])
self.assertEqual({'foo4': [1, 2]}, definition.get_argument_defaults())
def test_parse_options(self):
for argv, options, expected_options, message in self.provide_options():
input_ = ArgvInput(argv)
input_.bind(InputDefinition(options))
self.assertEqual(
expected_options,
input_.get_options(),
msg=message
)
def provide_invalid_input(self):
return [
(
['cli.py', '--foo'],
InputDefinition([
InputOption('foo', 'f', InputOption.VALUE_REQUIRED)
]),
'The "--foo" option requires a value.'
),
(
['cli.py', '-f'],
InputDefinition([
InputOption('foo', 'f', InputOption.VALUE_REQUIRED)
]),
'The "--foo" option requires a value.'
),
(
['cli.py', '-ffoo'],
InputDefinition([
InputOption('foo', 'f', InputOption.VALUE_NONE)
]),
'The "-o" option does not exist.'
),
(
['cli.py', '--foo=bar'],
InputDefinition([
InputOption('foo', 'f', InputOption.VALUE_NONE)
]),
'The "--foo" option does not accept a value.'
),
(
['cli.py', 'foo', 'bar'],
InputDefinition(),
'Too many arguments.'
),
(
['cli.py', '--foo'],
InputDefinition(),
'The "--foo" option does not exist.'
),
(
['cli.py', '-f'],
InputDefinition(),
'The "-f" option does not exist.'
),
(
['cli.py', '-1'],
InputDefinition([
InputArgument('number')
]),
'The "-1" option does not exist.'
)
]
def test_validate_options(self):
definition = InputDefinition([InputOption('opt', validator=Float())])
input = MockInput(definition)
input.validate_options()
# Wrong type
input = MockWrongInput(definition)
self.assertRaises(InvalidOption, input.validate_options)
def test_validate_arguments(self):
definition = InputDefinition(
[InputArgument('arg', validator=Integer())])
input = MockInput(definition)
input.validate_arguments()
# Wrong type
input = MockWrongInput(definition)
self.assertRaises(InvalidArgument, input.validate_arguments)
def test_parse_list_argument(self):
input_ = ArgvInput(['cli.py', 'foo', 'bar', 'baz', 'bat'])
input_.bind(
InputDefinition([
InputArgument('name', InputArgument.IS_LIST)
])
)
self.assertEqual(
{'name': ['foo', 'bar', 'baz', 'bat']},
input_.get_arguments()
)
def test_parse_arguments(self):
input_ = ArgvInput(['cli.py', 'foo'])
input_.bind(
InputDefinition([
InputArgument('name')
])
)
self.assertEqual({'name': 'foo'}, input_.get_arguments())
# parse is stateless
self.assertEqual({'name': 'foo'}, input_.get_arguments())
def test_init(self):
input = MockInput()
self.assertIsNotNone(input.definition)
self.assertEqual(input.arguments, {})
self.assertEqual(input.arguments, {})
definition = InputDefinition(
[InputArgument('arg'), InputOption('opt')])
input = MockInput(definition)
self.assertEqual(definition, input.definition)
self.assertEqual('57', input.arguments['arg'])
self.assertEqual('37.25', input.options['opt'])
def test_get_synopsis(self):
definition = InputDefinition([InputOption('foo')])
self.assertEqual('[--foo]', definition.get_synopsis())
definition = InputDefinition([InputOption('foo', 'f')])
self.assertEqual('[-f|--foo]', definition.get_synopsis())
definition = InputDefinition([InputOption('foo', 'f', InputOption.VALUE_REQUIRED)])
self.assertEqual('[-f|--foo FOO]', definition.get_synopsis())
definition = InputDefinition([InputOption('foo', 'f', InputOption.VALUE_OPTIONAL)])
self.assertEqual('[-f|--foo [FOO]]', definition.get_synopsis())
definition = InputDefinition([InputArgument('foo')])
self.assertEqual('[<foo>]', definition.get_synopsis())
definition = InputDefinition([InputArgument('foo', InputArgument.REQUIRED)])
self.assertEqual('<foo>', definition.get_synopsis())
definition = InputDefinition([InputArgument('foo', InputArgument.IS_LIST)])
self.assertEqual('[<foo>]...', definition.get_synopsis())
definition = InputDefinition([InputArgument('foo', InputArgument.REQUIRED | InputArgument.IS_LIST)])
self.assertEqual('<foo> (<foo>)...', definition.get_synopsis())
def test_as_text(self):
definition = InputDefinition([
InputArgument('foo', InputArgument.OPTIONAL, 'The foo argument'),
InputArgument('baz', InputArgument.OPTIONAL, 'The baz argument',
True),
InputArgument('bar',
InputArgument.OPTIONAL | InputArgument.IS_LIST,
'The bar argument', ['http://foo.com/']),
InputOption('foo', 'f', InputOption.VALUE_REQUIRED,
'The foo option'),
InputOption('baz', None, InputOption.VALUE_OPTIONAL,
'The baz option', False),
InputOption('bar', 'b', InputOption.VALUE_OPTIONAL,
'The bar option', 'bar'),
InputOption('qux', '',
InputOption.VALUE_OPTIONAL | InputOption.VALUE_IS_LIST,
'The qux option', ['http://foo.com/', 'bar'])
])
self.assertEqual(self.open_fixture('definition_astext.txt'),
definition.as_text())
