def testGenerateFlagBoolean(self):
a = yaml_command_schema.Argument('asdf', 'foo', 'foo help')
arg = arg_utils.GenerateFlag(fm.FakeMessage.bool1, a)
self.assertEqual(arg.name, '--foo')
self.assertEqual(
{'category': None, 'action': 'store_true', 'completer': None,
'help': 'foo help', 'hidden': False, 'required': False}, arg.kwargs)
def _GenerateArguments(self, prefix, message):
"""Gets the arguments to add to the parser that appear in the method body.
Args:
prefix: str, A string to prepend to the name of the flag. This is used
for flags representing fields of a submessage.
message: The apitools message to generate the flags for.
Returns:
{str, calliope.base.Argument}, A map of field name to argument.
"""
args = []
field_helps = arg_utils.FieldHelpDocs(message)
for field in message.all_fields():
field_help = field_helps.get(field.name, None)
name = self._GetArgName(field.name, field_help)
if not name:
continue
name = prefix + name
if field.variant == messages.Variant.MESSAGE:
sub_args = self._GenerateArguments(name + '.', field.type)
if sub_args:
help_text = (name + ': ' + field_help) if field_help else ''
group = base.ArgumentGroup(help=help_text)
args.append(group)
for arg in sub_args:
group.AddArgument(arg)
else:
attributes = yaml_command_schema.Argument(name, name, field_help)
arg = arg_utils.GenerateFlag(field, attributes, fix_bools=False,
category='MESSAGE')
if not arg.kwargs.get('help'):
arg.kwargs['help'] = 'API doc needs help for field [{}].'.format(name)
args.append(arg)
return args
def testGenerateFlagPositional(self):
a = yaml_command_schema.Argument('asdf', 'foo', 'foo help',
is_positional=True)
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(arg.name, 'foo')
kwargs = self._MakeKwargs()
del kwargs['required']
self.assertEqual(kwargs, arg.kwargs)
def testGenerateFlagEnumChoices(self):
a = yaml_command_schema.Argument('asdf', 'foo', 'foo help')
arg = arg_utils.GenerateFlag(fm.FakeMessage.enum1, a)
self.assertEqual(arg.name, '--foo')
self.assertEqual(
self._MakeKwargs(choices=['thing-one', 'thing-two'],
type=arg_utils.EnumNameToChoice),
arg.kwargs)
def _GenerateArguments(self):
"""Generates the arguments for the API fields of this method."""
message = self.method.GetRequestType()
args = self._CreateGroups()
for attributes in self.arg_info:
if attributes.api_field:
field_path = attributes.api_field
field = arg_utils.GetFieldFromMessage(message, field_path)
arg = arg_utils.GenerateFlag(field, attributes)
else:
arg = arg_utils.GenerateFlag(None, attributes)
if attributes.group:
args[attributes.group.group_id].AddArgument(arg)
else:
args[arg.name] = arg
return args
def testRepeated(self):
# Repeated simple type gets wrapped.
a = yaml_command_schema.Argument('foo', 'foo', 'foo help')
arg = arg_utils.GenerateFlag(fm.FakeMessage.string2, a)
self.assertTrue(isinstance(arg.kwargs['type'], arg_parsers.ArgList))
self.assertEqual(arg.kwargs['type'].element_type, six.text_type)
# Repeated complex type doesn't get re-wrapped.
a = yaml_command_schema.Argument('foo', 'foo', 'foo help',
type=arg_parsers.ArgList())
arg = arg_utils.GenerateFlag(fm.FakeMessage.string2, a)
self.assertIsNone(arg.kwargs['type'].element_type)
# Repeated with flattened ArgDict.
t = yaml_command_schema_util.ParseType(
{'arg_dict': {'flatten': True, 'spec': [
{'api_field': 'string1'}, {'api_field': 'string2'}]}})
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', type=t)
arg = arg_utils.GenerateFlag(fm.FakeMessage.repeated_message, a)
result = arg.kwargs['type']('a=b,c=d')
self.assertEqual(len(result), 2)
self.assertEqual(result[0],
fm.FakeMessage.InnerMessage(string1='a', string2='b'))
self.assertEqual(result[1],
fm.FakeMessage.InnerMessage(string1='c', string2='d'))
# Repeated with ArgDict.
t = yaml_command_schema_util.ParseType(
{'arg_dict': {'spec': [
{'api_field': 'string1', 'arg_name': 'a'},
{'api_field': 'string2', 'arg_name': 'b'}]}})
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', type=t)
arg = arg_utils.GenerateFlag(fm.FakeMessage.repeated_message, a)
result = arg.kwargs['type']('a=foo,b=bar')
self.assertEqual(result,
fm.FakeMessage.InnerMessage(string1='foo', string2='bar'))
# Not allowed to use ArgDict with non-repeated field.
with self.assertRaisesRegex(
arg_utils.ArgumentGenerationError,
r'Failed to generate argument for field \[string1\]: The given type '
r'can only be used on repeated fields.'):
arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
# Force repeated arg to be singular.
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', repeated=False)
arg = arg_utils.GenerateFlag(fm.FakeMessage.string2, a)
self.assertEqual(arg.kwargs['type'], six.text_type)
# Repeated with custom action is an error.
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', action='foo')
with self.assertRaisesRegex(
arg_utils.ArgumentGenerationError,
r'Failed to generate argument for field \[string2\]: The field is '
r'repeated but is using a custom action. You might want to set '
r'repeated: False in your arg spec.'):
arg_utils.GenerateFlag(fm.FakeMessage.string2, a)
def testGenerateFlagBasics(self):
a = yaml_command_schema.Argument('asdf', 'foo', 'foo help')
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(arg.name, '--foo')
self.assertEqual(self._MakeKwargs(), arg.kwargs)
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a, category='ASDF')
self.assertDictContainsSubset(self._MakeKwargs(category='ASDF'), arg.kwargs)
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', default='junk')
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(self._MakeKwargs(default='junk'), arg.kwargs)
a = yaml_command_schema.Argument(
'foo', 'foo', 'foo help',
choices=[yaml_command_schema_util.Choice({'arg_value': 'a',
'enum_value': 'b'}),
yaml_command_schema_util.Choice({'arg_value': 'c',
'enum_value': 'd'})])
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(self._MakeKwargs(choices=['a', 'c']), arg.kwargs)
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', completer='junk')
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(self._MakeKwargs(completer='junk'), arg.kwargs)
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', hidden=True)
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(self._MakeKwargs(hidden=True), arg.kwargs)
a = yaml_command_schema.Argument('foo', 'foo', 'foo help', required=True)
arg = arg_utils.GenerateFlag(fm.FakeMessage.string1, a)
self.assertEqual(self._MakeKwargs(required=True), arg.kwargs)
# No api_field
a = yaml_command_schema.Argument(None, 'foo', 'foo help', repeated=False)
arg = arg_utils.GenerateFlag(None, a)
self.assertEqual(arg.kwargs['type'], None)
# Unknown type
a = yaml_command_schema.Argument('foo', 'foo', 'foo help')
with self.assertRaisesRegex(
arg_utils.ArgumentGenerationError,
r'Failed to generate argument for field \[message1\]: The field is of '
r'an unknown type.'):
arg_utils.GenerateFlag(fm.FakeMessage.message1, a)
def Generate(self, message):
"""Generates and returns the base argument.
Args:
message: The API message, None for non-resource args.
Returns:
The base argument.
"""
if self.api_field:
field = arg_utils.GetFieldFromMessage(message, self.api_field)
else:
field = None
return arg_utils.GenerateFlag(field, self)
def Add(field, name):
a = yaml_command_schema.Argument('asdf', name, 'help')
arg_utils.GenerateFlag(field, a).AddToParser(parser)
def testGenerateUnspecifiedDefault(self):
a = yaml_command_schema.Argument.FromData(
{'help_text': 'foo help', 'api_field': 'asdf', 'arg_name': 'foo'})
arg = arg_utils.GenerateFlag(fm.FakeMessage.string2, a)
self.assertEqual(a.default, arg_utils.UNSPECIFIED)
self.assertNotIn('default', arg.kwargs)
