def _convert_method_def_to_data_value(method_def):
"""
Converts a :class:`vmware.vapi.core.MethodDefinition` object
to :class:`vmware.vapi.data.value.DataValue` object
:type method_def: :class:`vmware.vapi.core.MethodDefinition`
:param method_def: Method definition
:rtype: :class:`vmware.vapi.data.value.DataValue`
:return: Data value object representing method definition
"""
output = StructValue(
name='com.vmware.vapi.std.introspection.operation.info',
values={
'input_definition':
convert_data_def_to_data_value(
method_def.get_input_definition()),
'output_definition':
convert_data_def_to_data_value(
method_def.get_output_definition()),
'error_definitions':
ListValue(values=[
convert_data_def_to_data_value(error_def)
for error_def in method_def.get_error_definitions()
])
})
return output
def __init__(self, load_introspection=True):
"""
Initialize LocalProvider
:type load_introspection: :class:`bool`
:param load_introspection: If true, load introspection services
"""
ApiProvider.__init__(self)
self._name = "LocalProvider"
# key = service id, value = api interface
self._service_map = {}
self._introspector = introspection.LocalProviderIntrospector(
self._name)
if load_introspection:
self.add_interface(self._introspector.get_introspection_services())
self._error_defs_to_augment = [
self._internal_server_error_def,
self._invalid_argument_def,
self._operation_not_found_def,
]
# these are the errors that should be augmented
# when `get` operation is invoked on
# com.vmware.vapi.std.introspection.Operation
self._error_values_to_augment = [
convert_data_def_to_data_value(error_def)
for error_def in self._error_defs_to_augment
]
def test_struct_ref_to_value(self):
actual_output = convert_data_def_to_data_value(
StructRefDefinition('mock'))
expected_output = StructValue(Introspection.DATA_DEFINITION)
expected_output.set_field('type', StringValue('STRUCTURE_REF'))
expected_output.set_field('fields', OptionalValue())
expected_output.set_field('name', OptionalValue(StringValue('mock')))
expected_output.set_field('element_definition', OptionalValue())
self.assertEqual(actual_output, expected_output)
def test_generic_def_to_value(self):
for typ_def, typ in [(OptionalDefinition, 'OPTIONAL'),
(ListDefinition, 'LIST')]:
typ_def = typ_def(StringDefinition())
actual_output = convert_data_def_to_data_value(typ_def)
expected_output = StructValue(Introspection.DATA_DEFINITION)
element_value = self.generate_primitive_value('STRING')
expected_output.set_field('type', StringValue(typ))
expected_output.set_field('fields', OptionalValue())
expected_output.set_field('name', OptionalValue())
expected_output.set_field('element_definition',
OptionalValue(element_value))
self.assertEqual(actual_output, expected_output)
def test_error_to_value(self):
struct_def = ErrorDefinition('mock', [('field1', StringDefinition())])
actual_output = convert_data_def_to_data_value(struct_def)
expected_output = StructValue(Introspection.DATA_DEFINITION)
expected_output.set_field('type', StringValue('ERROR'))
expected_output.set_field('name', OptionalValue(StringValue('mock')))
expected_output.set_field('element_definition', OptionalValue())
field_value = self.generate_primitive_value('STRING')
field_entry = StructValue(MAP_ENTRY)
field_entry.set_field('key', StringValue('field1'))
field_entry.set_field('value', field_value)
field_values = ListValue()
field_values.add(field_entry)
expected_output.set_field('fields', OptionalValue(field_values))
self.assertEqual(actual_output, expected_output)
def test_primitive_def_to_value(self):
for typ_def_class, typ in [(VoidDefinition, 'VOID'),
(IntegerDefinition, 'LONG'),
(DoubleDefinition, 'DOUBLE'),
(BooleanDefinition, 'BOOLEAN'),
(StringDefinition, 'STRING'),
(BlobDefinition, 'BINARY'),
(OpaqueDefinition, 'OPAQUE'),
(SecretDefinition, 'SECRET'),
(DynamicStructDefinition,
'DYNAMIC_STRUCTURE'),
(AnyErrorDefinition, 'ANY_ERROR')]:
actual_output = convert_data_def_to_data_value(typ_def_class())
expected_output = self.generate_primitive_value(typ)
self.assertEqual(actual_output, expected_output)
def __init__(self, next_provider=None, errors_to_augment=None, name=None):
"""
Initialize ApiProviderFilter
:type next_provider: :class:`vmware.vapi.core.ApiProvider` or ``None``
:param next_provider: API Provider to invoke the requests
:type errors_to_augment: :class:`list` of
:class:`vmware.vapi.data.definition.ErrorDefinition` or ``None``
:param errors_to_augment: List of error definitions to be added to
method definitions
:type name: :class:`str`
:param name: The name of the filter
"""
ApiProvider.__init__(self)
self.name = name if name is not None else self.__class__.__name__
self.next_provider = next_provider
self._error_defs_to_augment = errors_to_augment or []
self._error_values_to_augment = [
convert_data_def_to_data_value(error_def)
for error_def in self._error_defs_to_augment
]
report_undeclared_error: report_undeclared_error_id,
raise_python_exception: raise_python_exception_id,
return_invalid_output: return_invalid_output_id,
}
internal_server_error_def = make_std_error_def(
'com.vmware.vapi.std.errors.internal_server_error')
invalid_argument_def = make_std_error_def(
'com.vmware.vapi.std.errors.invalid_argument')
not_found_error_def = make_std_error_def(
'com.vmware.vapi.std.errors.not_found')
operation_not_found_def = make_std_error_def(
'com.vmware.vapi.std.errors.operation_not_found')
error_values = ListValue([
convert_data_def_to_data_value(internal_server_error_def),
convert_data_def_to_data_value(invalid_argument_def),
convert_data_def_to_data_value(operation_not_found_def)
])
_msg = Message('mockup.message.id', 'mockup error message')
not_found_error = make_error_value_from_msgs(not_found_error_def, _msg)
param_name = 'param'
class MockupApiInterface(ApiInterface):
def __init__(self):
pass
def get_identifier(self):
('service_name', StringDefinition()),
('operation_name', StringDefinition()),
('operation_input', OpaqueDefinition()),
])
mock_input_def = StructDefinition('input', [('raise', BooleanDefinition())])
not_found_error_def = make_std_error_def(
'com.vmware.vapi.std.errors.not_found')
errors = [
'com.vmware.vapi.std.errors.not_found',
'com.vmware.vapi.std.errors.internal_server_error',
'com.vmware.vapi.std.errors.invalid_argument',
'com.vmware.vapi.std.errors.operation_not_found',
]
error_defs = [make_std_error_def(error) for error in errors]
error_values = ListValue(
[convert_data_def_to_data_value(error_def) for error_def in error_defs])
class MockupApiInterface(ApiInterface):
def __init__(self, interface_id):
self._interface_id = interface_id
self.counters = {}
for name in [
mock_method_name, pre_method_name, post_method_name,
veto_method_name
]:
self.counters[name] = 0
def get_identifier(self):
return self._interface_id
