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_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_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_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"))