def test_has_fields_of_positive2(self): prop = Properties(int_val=10, str_val='STRING_PROP', bool_val=True, opt_int_val=11, list_val=[], nested_val=NestedProperties(int_val=100)) msg_list = self.has_fields_of_validator.validate( prop.get_struct_value(), dynamic_struct_binding_type) raise_core_exception(msg_list)
def test_has_fields_of_positive3(self): struct_value = StructValue(name='Properties2', values={ 'list_val': ListValue(), 'nested_val': StructValue('NestedProperties2') }) msg_list = self.has_fields_of_validator.validate( struct_value, dynamic_struct_binding_type2) raise_core_exception(msg_list)
def test_has_fields_of_positive2(self): prop = Properties(int_val=10, str_val='STRING_PROP', bool_val=True, opt_int_val=11, list_val=[], nested_val=NestedProperties(int_val=100)) values = {} for k, v in prop.get_struct_value().get_fields(): if k != 'opt_int_val': values[k] = v msg_list = self.has_fields_of_validator.validate( StructValue(name='Properties', values=values), dynamic_struct_binding_type) raise_core_exception(msg_list)
def validate_struct_value(cls, struct_value): """ Validate if the given struct value satisfies all the constraints of this VapiStruct. :type struct_value: :class:`vmware.vapi.data.value.StructValue` :param struct_value: StructValue to be validated :type validators: :class:`list` of :class:`vmware.vapi.data.validator.Validator` :param validators: List of validators :raise :class:`vmware.vapi.exception.CoreException` if a constraint is not satisfied """ if cls._validator_list: for validator in cls._validator_list: msg_list = validator.validate(struct_value, None) raise_core_exception(msg_list)
def test_union_validator_positive3(self): # Test Optional union cases union_validator = UnionValidator( 'test_enum', { 'LONG': [('long_val', True), ('opt_long_val', False)], 'STRING': [('string_val', True)], 'NONE': [], }) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': StringValue('LONG'), 'long_val': IntegerValue(100), 'opt_long_val': IntegerValue(120) })) raise_core_exception(msg_list) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': StringValue('LONG'), 'long_val': IntegerValue(100), })) raise_core_exception(msg_list) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': StringValue('NONE'), })) raise_core_exception(msg_list)
def test_union_validator_positive2(self): # Test Optional union tags union_validator = UnionValidator( 'test_enum', { 'LONG': [('long_val', True)], 'STRING': [('string_val', True)], 'NONE': [], }) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': OptionalValue(StringValue('LONG')), 'long_val': OptionalValue(IntegerValue(100)) })) raise_core_exception(msg_list) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': OptionalValue(StringValue('NONE')), })) raise_core_exception(msg_list) msg_list = union_validator.validate( StructValue(name='TestStruct', values={ 'test_enum': OptionalValue(), })) raise_core_exception(msg_list)
def native_invoke(self, ctx, method_name, kwargs): """ Invokes the method corresponding to the given method name with the kwargs. In this method, python native values are converted to vAPI runtime values, operation is invoked and the result are converted back to python native values :type ctx: :class:`vmware.vapi.core.ExecutionContext` :param ctx: Execution context for this method :type method_name: :class:`str` :param method_name: Method name :type kwargs: :class:`dict` :param kwargs: arguments to be passed to the method :rtype: :class:`object` :return: Method result """ op_info = self._operations.get(method_name) if op_info is None: raise Exception('Could not find %s method in %s interface' % (method_name, str(self._iface_id))) # Convert input input_type = op_info['input_type'] data_val = TypeConverter.convert_to_vapi(kwargs, input_type, self._rest_converter_mode) # Validate input validators = op_info['input_value_validator_list'] for validator in validators: msg_list = validator.validate(data_val, input_type) raise_core_exception(msg_list) if OPID in ctx.application_context: logger.debug( 'opId: %s invoke: interface_id: %s, operation_name: %s', ctx.application_context[OPID], self._iface_id.get_name(), method_name) else: logger.debug('invoke: interface_id: %s, operation_name: %s', self._iface_id, method_name) # Invoke method_id = MethodIdentifier(self._iface_id, method_name) if self._use_rest: operation_rest_metadata = None if self._rest_metadata: operation_rest_metadata = self._rest_metadata.get(method_name) if operation_rest_metadata is None: msg = message_factory.get_message( 'vapi.bindings.stub.rest_metadata.unavailable') logger.debug(msg) raise CoreException(msg) else: if self._is_vapi_rest is not None and not self._is_vapi_rest: # If the rest format is not vapi, then the server # (OpenAPI based) will not be supporting json-rpc. msg = message_factory.get_message( 'vapi.bindings.stub.jsonrpc.unsupported') logger.debug(msg) raise CoreException(msg) method_result = self.invoke(ctx, method_id, data_val) # Validate output if method_result.success(): validators = op_info['output_validator_list'] output_type = op_info['output_type'] for validator in validators: msg_list = validator.validate(method_result.output, output_type) raise_core_exception(msg_list) # Convert output return TypeConverter.convert_to_python(method_result.output, output_type, self._config.resolver, self._rest_converter_mode) else: # Convert error errors = op_info['errors'] error_type = errors.get(method_result.error.name) if error_type is None: error_type = self._config.resolver.resolve( method_result.error.name) if error_type is None: logger.warning('Unable to convert unexpected vAPI error %s ' + 'to native Python exception', method_result.error.name) vapi_error = UnresolvedError(method_result.error) raise vapi_error raise TypeConverter.convert_to_python(method_result.error, # pylint: disable=E0702 error_type, self._config.resolver, self._rest_converter_mode)