def test_get_description(self):
"""
InputArgument.get_description() returns the message description
"""
argument = InputArgument('foo', None, 'Some description')
self.assertEqual('Some description', argument.get_description(),
msg='.get_description() returns the message description')
def test_get_default(self):
"""
InputArgument.get_default() returns the default value
"""
argument = InputArgument('foo', InputArgument.OPTIONAL, '', 'default')
self.assertEqual('default', argument.get_default(),
msg='.get_default() returns the default value')
def test_merge_application_definition(self):
"""
Command.merge_application_definition() merges command and application.
"""
application1 = Application()
application1.get_definition().add_arguments([InputArgument('foo')])
application1.get_definition().add_options([InputOption('bar')])
command = SomeCommand()
command.set_application(application1)
command.set_definition(
InputDefinition([
InputArgument('bar'),
InputOption('foo')
])
)
command.merge_application_definition()
self.assertTrue(command.get_definition().has_argument('foo'))
self.assertTrue(command.get_definition().has_option('foo'))
self.assertTrue(command.get_definition().has_argument('bar'))
self.assertTrue(command.get_definition().has_option('bar'))
# It should not merge the definitions twice
command.merge_application_definition()
self.assertEqual(3, command.get_definition().get_argument_count())
def test_get_default(self):
"""
InputArgument.get_default() returns the default value
"""
argument = InputArgument('foo', InputArgument.OPTIONAL, '', 'default')
self.assertEqual('default',
argument.get_default(),
msg='.get_default() returns the default value')
def test_get_description(self):
"""
InputArgument.get_description() returns the message description
"""
argument = InputArgument('foo', None, 'Some description')
self.assertEqual(
'Some description',
argument.get_description(),
msg='.get_description() returns the message description')
def test_is_list(self):
"""
InputArgument.is_list() returns true if the argument can be an array'
"""
argument = InputArgument('foo', InputArgument.IS_LIST)
self.assertTrue(argument.is_list())
argument = InputArgument(
'foo', InputArgument.OPTIONAL | InputArgument.IS_LIST)
self.assertTrue(argument.is_list())
argument = InputArgument('foo', InputArgument.OPTIONAL)
self.assertFalse(argument.is_list())
def test_set_default(self):
"""
InputArgument.set_default() sets the default value
"""
argument = InputArgument('foo', InputArgument.OPTIONAL, '', 'default')
argument.set_default(None)
self.assertEqual(
None,
argument.get_default(),
msg='.set_default() can reset the default value by passing None')
argument.set_default('another')
self.assertEqual('another',
argument.get_default(),
msg='.set_default() changes the default value')
argument = InputArgument('foo', InputArgument.REQUIRED)
self.assertRaises(Exception, argument.set_default, 'default')
def test_set_default(self):
"""
InputArgument.set_default() sets the default value
"""
argument = InputArgument('foo', InputArgument.OPTIONAL, '', 'default')
argument.set_default(None)
self.assertEqual(None, argument.get_default(),
msg='.set_default() can reset the default value by passing None')
argument.set_default('another')
self.assertEqual('another', argument.get_default(),
msg='.set_default() changes the default value')
argument = InputArgument('foo', InputArgument.REQUIRED)
self.assertRaises(Exception, argument.set_default, 'default')
def test_set_get_definition(self):
"""
Command.get/set_definition properly sets and gets definition
"""
command = SomeCommand()
definition = InputDefinition()
ret = command.set_definition(definition)
self.assertEqual(command, ret, msg='.set_definition() implements a fluent interface')
self.assertEqual(definition, command.get_definition(),
msg='.set_definition() sets the current InputDefinition instance')
command.set_definition([InputArgument('foo'), InputOption('bar')])
self.assertTrue(command.get_definition().has_argument('foo'),
msg='.set_definition() also takes an array of InputArguments and InputOptions as an argument')
self.assertTrue(command.get_definition().has_option('bar'),
msg='.set_definition() also takes an array of InputArguments and InputOptions as an argument')
command.set_definition(InputDefinition())
def test_is_list(self):
"""
InputArgument.is_list() returns true if the argument can be an array'
"""
argument = InputArgument('foo', InputArgument.IS_LIST)
self.assertTrue(argument.is_list())
argument = InputArgument('foo', InputArgument.OPTIONAL | InputArgument.IS_LIST)
self.assertTrue(argument.is_list())
argument = InputArgument('foo', InputArgument.OPTIONAL)
self.assertFalse(argument.is_list())
def test_merge_application_definition_without_args_then_with_args_adds_args(self):
application1 = Application()
application1.get_definition().add_arguments([InputArgument('foo')])
application1.get_definition().add_options([InputOption('bar')])
command = SomeCommand()
command.set_application(application1)
command.set_definition(InputDefinition())
command.merge_application_definition(False)
self.assertFalse(command.get_definition().has_argument('foo'))
self.assertTrue(command.get_definition().has_option('bar'))
command.merge_application_definition(True)
self.assertTrue(command.get_definition().has_argument('foo'))
# It should not merge the definitions twice
command.merge_application_definition()
self.assertEqual(2, command.get_definition().get_argument_count())
def test_from_dict_plain_dict(self):
"""
InputArgument.from_dict() returns an InputArgument instance given a dict.
"""
validator = Integer()
argument_dict = {
'name': 'foo',
'description': 'The foo argument.',
'required': False,
'list': True,
'default': ['default'],
'validator': validator
}
argument = InputArgument.from_dict(argument_dict)
self.assertTrue(InputArgument, argument)
self.assertEqual('foo', argument.get_name())
self.assertEqual('The foo argument.', argument.get_description())
self.assertEqual(['default'], argument.get_default())
self.assertTrue(argument.is_list())
self.assertFalse(argument.is_required())
self.assertEqual(validator, argument.get_validator())
def test_from_dict_plain_dict(self):
"""
InputArgument.from_dict() returns an InputArgument instance given a dict.
"""
validator = Integer()
argument_dict = {
'name': 'foo',
'description': 'The foo argument.',
'required': False,
'list': True,
'default': ['default'],
'validator': validator
}
argument = InputArgument.from_dict(argument_dict)
self.assertTrue(InputArgument, argument)
self.assertEqual('foo', argument.get_name())
self.assertEqual('The foo argument.', argument.get_description())
self.assertEqual(['default'], argument.get_default())
self.assertTrue(argument.is_list())
self.assertFalse(argument.is_required())
self.assertEqual(validator, argument.get_validator())
def test_init(self):
"""
InputArgument.__init__() behaves properly
"""
argument = InputArgument('foo')
self.assertEqual('foo', argument.get_name(), msg='__init__() takes a name as its first argument')
# mode argument
argument = InputArgument('foo')
self.assertFalse(argument.is_required(), msg='__init__() gives a "InputArgument.OPTIONAL" mode by default')
argument = InputArgument('foo', None)
self.assertFalse(argument.is_required(), msg='__init__() can take "InputArgument.OPTIONAL" as its mode')
argument = InputArgument('foo', InputArgument.OPTIONAL)
self.assertFalse(argument.is_required(), msg='__init__() can take "InputArgument.OPTIONAL" as its mode')
argument = InputArgument('foo', InputArgument.REQUIRED)
self.assertTrue(argument.is_required(), msg='__init__() can take "InputArgument.REQUIRED" as its mode')
self.assertRaises(Exception, InputArgument, 'foo', 'ANOTHER_MODE')
self.assertRaises(Exception, InputArgument, 'foo', -1)
validator = Integer()
argument = InputArgument('foo', None, validator=validator)
self.assertEqual(validator, argument.get_validator())
# Named validator
validator = 'integer'
argument = InputArgument('foo', None, validator=validator)
self.assertIsInstance(argument.get_validator(), Integer)
# Native type
validator = int
argument = InputArgument('foo', None, validator=validator)
self.assertIsInstance(argument.get_validator(), Integer)
def test_init(self):
"""
InputArgument.__init__() behaves properly
"""
argument = InputArgument('foo')
self.assertEqual('foo',
argument.get_name(),
msg='__init__() takes a name as its first argument')
# mode argument
argument = InputArgument('foo')
self.assertFalse(
argument.is_required(),
msg='__init__() gives a "InputArgument.OPTIONAL" mode by default')
argument = InputArgument('foo', None)
self.assertFalse(
argument.is_required(),
msg='__init__() can take "InputArgument.OPTIONAL" as its mode')
argument = InputArgument('foo', InputArgument.OPTIONAL)
self.assertFalse(
argument.is_required(),
msg='__init__() can take "InputArgument.OPTIONAL" as its mode')
argument = InputArgument('foo', InputArgument.REQUIRED)
self.assertTrue(
argument.is_required(),
msg='__init__() can take "InputArgument.REQUIRED" as its mode')
self.assertRaises(Exception, InputArgument, 'foo', 'ANOTHER_MODE')
self.assertRaises(Exception, InputArgument, 'foo', -1)
validator = Integer()
argument = InputArgument('foo', None, validator=validator)
self.assertEqual(validator, argument.get_validator())
# Named validator
validator = 'integer'
argument = InputArgument('foo', None, validator=validator)
self.assertIsInstance(argument.get_validator(), Integer)
# Native type
validator = int
argument = InputArgument('foo', None, validator=validator)
self.assertIsInstance(argument.get_validator(), Integer)
