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_add_options(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertEqual([self.foo], definition.get_options())
definition.add_options([self.bar])
self.assertEqual([self.foo, self.bar], definition.get_options())
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_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_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_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_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_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_init_arguments(self):
self.initialize_arguments()
definition = InputDefinition()
self.assertEqual([], definition.get_arguments())
definition = InputDefinition([self.foo, self.bar])
self.assertEqual([self.foo, self.bar], definition.get_arguments())
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_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_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 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_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_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_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_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 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_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_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_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_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_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())
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_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_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_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())
def test_add_options(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertEqual([self.foo], definition.get_options())
definition.add_options([self.bar])
self.assertEqual([self.foo, self.bar], definition.get_options())
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_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_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_setting_input_definition_overwrites_default_values(self):
application = Application()
application.set_auto_exit(False)
application.set_catch_exceptions(False)
application.set_definition(InputDefinition([
InputOption('--custom', '-c',
InputOption.VALUE_NONE,
'Set the custom input definition.')
]))
definition = application.get_definition()
self.assertFalse(definition.has_argument('command'))
self.assertFalse(definition.has_option('help'))
self.assertFalse(definition.has_option('quiet'))
self.assertFalse(definition.has_option('verbose'))
self.assertFalse(definition.has_option('version'))
self.assertFalse(definition.has_option('ansi'))
self.assertFalse(definition.has_option('no-ansi'))
self.assertFalse(definition.has_option('no-interaction'))
self.assertTrue(definition.has_option('custom'))
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_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_option_for_multi_shortcut(self):
self.initialize_options()
definition = InputDefinition([self.multi])
self.assertEqual(self.multi, definition.get_option_for_shortcut("m"))
self.assertEqual(self.multi, definition.get_option_for_shortcut("mmm"))
def test_has_shortcut(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertTrue(definition.has_shortcut("f"))
self.assertFalse(definition.has_shortcut("b"))
def test_get_option_for_shortcut(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertEqual(self.foo, definition.get_option_for_shortcut("f"))
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_has_option(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertTrue(definition.has_option("foo"))
self.assertFalse(definition.has_option("bar"))
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 test_get_argument(self):
self.initialize_arguments()
definition = InputDefinition()
definition.add_arguments([self.foo])
self.assertEqual(self.foo, definition.get_argument("foo"))
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_parse_single_dash_argument(self):
input_ = ArgvInput(['cli.py', '-'])
input_.bind(InputDefinition([
InputArgument('file')
]))
self.assertEqual({'file': '-'}, input_.get_arguments())
def test_get_option(self):
self.initialize_options()
definition = InputDefinition([self.foo])
self.assertEqual(self.foo, definition.get_option("foo"))
