/** * @expectedException \LogicException * @expectedExceptionMessage Class "\Some\Class" does not exist. Please note that namespace must be specified. */ public function testResolveObjectTypeWithConfiguredAttributeAndNonExistedClass() { $code = 'some_code'; $value = new \stdClass(); $context = '\\Some\\Class'; $config = ['Some\\Class' => ['some_code' => ['type' => '\\Some\\Class']]]; $this->typeProcessor->expects($this->once())->method('getArrayItemType')->with('\\Some\\Class')->willReturn('\\Some\\Class'); $this->configMock->expects($this->once())->method('get')->willReturn($config); $this->model->resolveObjectType($code, $value, $context); }
/** * Ensure that specified type is either a simple type or a valid service data type. * * @param string $typeName * @return $this * @throws \Exception In case when type is invalid */ protected function validateType($typeName) { if ($this->typeProcessor->isTypeSimple($typeName)) { return $this; } if ($this->typeProcessor->isArrayType($typeName)) { $arrayItemType = $this->typeProcessor->getArrayItemType($typeName); $this->methodsMap->getMethodsMap($arrayItemType); } else { $this->methodsMap->getMethodsMap($typeName); } return $this; }
/** * All types names should be absolute (include namespace) in the registry. * First '\' will be removed if exists. * Array types (\Some\Type[]) will be converted into simple types (Some\Type). * Simple types names will be converted to it's canonical versions (bool => boolean). * * @param string $type * @return string */ public function normalizeType($type) { $result = $this->_typeProcessor->normalizeType($type); if ($result && $result[0] == '\\') { $result = substr($result, 1); // remove leading slash } if ($this->isArray($result)) { $result = substr($result, 0, -2); // remove '[]' at the end } return $result; }
public function testGetParameterDescription() { $class = new ClassReflection("\\Magento\\Framework\\Reflection\\Test\\Unit\\DataObject"); $methodReflection = $class->getMethod('setName'); $paramsReflection = $methodReflection->getParameters(); $this->assertEquals('Name of the attribute', $this->_typeProcessor->getParamDescription($paramsReflection[0])); }
/** * Analyze $type and save type properties into the registry. * * @param string $type * @return \Praxigento\Core\Reflection\Data\Property[] array with type properties or empty array for simple types. */ public function register($type) { $typeNorm = $this->_toolsType->normalizeType($type); $isSimple = $this->_typeProcessor->isTypeSimple($typeNorm); if (!isset($this->_registry[$typeNorm])) { if (!$isSimple) { /* analyze properties for complex type */ $this->_registry[$typeNorm] = []; /* process annotated methods */ /** @var \Zend\Code\Reflection\ClassReflection $reflection */ $reflection = new \Zend\Code\Reflection\ClassReflection($typeNorm); $docBlock = $reflection->getDocBlock(); if ($docBlock) { $this->_processDocBlock($typeNorm, $docBlock); } /* process normal methods (not annotated) */ $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC); $this->_processMethods($typeNorm, $methods); } else { /* this is simple type w/o props */ $this->_registry[$typeNorm] = []; } } return $this->_registry[$typeNorm]; }
/** * @param ExtensibleDataInterface $dataObject * @param string $getterMethodName * @param string $methodName * @param array $value * @param string $interfaceName * @return $this */ protected function setComplexValue(ExtensibleDataInterface $dataObject, $getterMethodName, $methodName, array $value, $interfaceName) { if ($interfaceName == null) { $interfaceName = get_class($dataObject); } $returnType = $this->methodsMapProcessor->getMethodReturnType($interfaceName, $getterMethodName); if ($this->typeProcessor->isTypeSimple($returnType)) { $dataObject->{$methodName}($value); return $this; } if ($this->typeProcessor->isArrayType($returnType)) { $type = $this->typeProcessor->getArrayItemType($returnType); $objects = []; foreach ($value as $arrayElementData) { $object = $this->objectFactory->create($type, []); $this->populateWithArray($object, $arrayElementData, $type); $objects[] = $object; } $dataObject->{$methodName}($objects); return $this; } if (is_subclass_of($returnType, '\\Magento\\Framework\\Api\\ExtensibleDataInterface')) { $object = $this->objectFactory->create($returnType, []); $this->populateWithArray($object, $value, $returnType); } else { if (is_subclass_of($returnType, '\\Magento\\Framework\\Api\\ExtensionAttributesInterface')) { $object = $this->extensionFactory->create(get_class($dataObject), $value); } else { $object = $this->objectFactory->create($returnType, $value); } } $dataObject->{$methodName}($object); return $this; }
/** * Convert data from array to Data Object representation if type is Data Object or array of Data Objects. * * @param mixed $data * @param string $type Convert given value to the this type * @return mixed * @throws \Magento\Framework\Exception\LocalizedException */ public function convertValue($data, $type) { $isArrayType = $this->typeProcessor->isArrayType($type); if ($isArrayType && isset($data['item'])) { $data = $this->_removeSoapItemNode($data); } if ($this->typeProcessor->isTypeSimple($type) || $this->typeProcessor->isTypeAny($type)) { $result = $this->typeProcessor->processSimpleAndAnyType($data, $type); } else { /** Complex type or array of complex types */ if ($isArrayType) { // Initializing the result for array type else it will return null for empty array $result = is_array($data) ? [] : null; $itemType = $this->typeProcessor->getArrayItemType($type); if (is_array($data)) { foreach ($data as $key => $item) { $result[$key] = $this->_createFromArray($itemType, $item); } } } else { $result = $this->_createFromArray($type, $data); } } return $result; }
/** @inheritdoc */ protected function _processMethod(\Zend\Code\Reflection\MethodReflection $methodReflection, $typeName) { /* skip basic methods of the DataObjects */ $name = $methodReflection->getName(); if ($name != self::SKIP_DATA && $name != self::SKIP_ITERATOR && $name != self::SKIP_DATA_UNSET) { parent::_processMethod($methodReflection, $typeName); } }
/** * Collect data about complex types call info. * * Walks through all requested services and checks all methods 'in' and 'out' parameters. * * @param array $requestedServiceMetadata * @return void */ protected function collectCallInfo($requestedServiceMetadata) { foreach ($requestedServiceMetadata as $serviceName => $serviceData) { foreach ($serviceData['methods'] as $methodName => $methodData) { $this->typeProcessor->processInterfaceCallInfo($methodData['interface'], $serviceName, $methodName); } } }
/** * {@inheritdoc} */ public function resolveObjectType($attributeCode, $value, $context) { if (!is_object($value)) { throw new \InvalidArgumentException('Provided value is not object type'); } $data = $this->config->get(); $context = trim($context, '\\'); $config = isset($data[$context]) ? $data[$context] : []; $output = get_class($value); if (isset($config[$attributeCode])) { $type = $config[$attributeCode]['type']; $output = $this->typeProcessor->getArrayItemType($type); if (!(class_exists($output) || interface_exists($output))) { throw new \LogicException(sprintf('Class "%s" does not exist. Please note that namespace must be specified.', $type)); } } return $output; }
/** * Retrieve method full documentation description. * * @param \Zend\Code\Reflection\MethodReflection $method * @return string */ protected function extractMethodDescription(\Zend\Code\Reflection\MethodReflection $method) { $methodReflection = new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()); $docBlock = $methodReflection->getDocBlock(); if (!$docBlock) { throw new \LogicException('The docBlock of the method ' . $method->getDeclaringClass()->getName() . '::' . $method->getName() . ' is empty.'); } return $this->_typeProcessor->getDescription($docBlock); }
/** * Retrieve class full documentation description. * * @param string $className * @return string */ public function extractClassDescription($className) { $classReflection = new \Zend\Code\Reflection\ClassReflection($className); $docBlock = $classReflection->getDocBlock(); if (!$docBlock) { return ''; } return $this->_typeProcessor->getDescription($docBlock); }
/** * Test exception for handle * * @expectedException \Magento\Framework\Webapi\Exception * @expectedExceptionMessage exception message */ public function testHandleWithException() { $genWSDL = 'generatedWSDL'; $exceptionMsg = 'exception message'; $requestedService = ['catalogProduct']; $serviceMetadata = ['methods' => ['methodName' => ['interface' => 'aInterface']]]; $this->serviceMetadata->expects($this->any())->method('getServiceMetadata')->willReturn($serviceMetadata); $this->_typeProcessor->expects($this->once())->method('processInterfaceCallInfo')->willThrowException(new \Magento\Framework\Webapi\Exception(__($exceptionMsg))); $this->assertEquals($genWSDL, $this->_wsdlGenerator->generate($requestedService, 'http://', 'magento.host', '/soap/default')); }
/** * Retrieve method info * * @param \ReflectionMethod $method * @return array */ protected function _getMethodInfo(\ReflectionMethod $method) { if (substr($method->getName(), 0, 2) == 'is') { $propertyName = substr($method->getName(), 2); } else { $propertyName = substr($method->getName(), 3); } $returnType = $this->typeProcessor->getGetterReturnType((new ClassReflection($this->_getSourceClassName()))->getMethod($method->getName())); $fieldName = strtolower(preg_replace('/(.)([A-Z])/', "\$1_\$2", $propertyName)); $methodInfo = ['name' => 'set' . $propertyName, 'parameters' => [['name' => lcfirst($propertyName)]], 'body' => "\$this->_set('{$fieldName}', \$" . lcfirst($propertyName) . ");" . PHP_EOL . "return \$this;", 'docblock' => ['tags' => [['name' => 'param', 'description' => $returnType['type'] . " \$" . lcfirst($propertyName)], ['name' => 'return', 'description' => '$this']]]]; return $methodInfo; }
/** * Add separate flow for annotated data objects, all other objects are processed by original code. * * @param \Magento\Framework\Webapi\ServiceInputProcessor $subject * @param \Closure $proceed * @param $data * @param $type * @return mixed */ public function aroundConvertValue(\Magento\Framework\Webapi\ServiceInputProcessor $subject, \Closure $proceed, $data, $type) { $result = null; if (is_subclass_of($type, \Flancer32\Lib\DataObject::class)) { if ($this->_typeProcessor->isTypeSimple($type) || $this->_typeProcessor->isTypeAny($type)) { $result = $this->_typeProcessor->processSimpleAndAnyType($data, $type); } else { /** Complex type or array of complex types */ $isArrayType = $this->_typeProcessor->isArrayType($type); if ($isArrayType) { // Initializing the result for array type else it will return null for empty array $itemType = $this->_typeProcessor->getArrayItemType($type); if (is_array($data)) { $result = []; foreach ($data as $key => $item) { $result[$key] = $this->_parser->parseArrayData($itemType, $item); } } } else { if (is_null($data)) { // do nothing, result is null } else { $result = $this->_parser->parseArrayData($type, $data); } } } } else { $result = $proceed($data, $type); } return $result; }
/** * @param mixed $dataObject * @param string $getterMethodName * @param string $methodName * @param array $value * @param string $interfaceName * @return $this * @SuppressWarnings(PHPMD.CyclomaticComplexity) */ protected function setComplexValue($dataObject, $getterMethodName, $methodName, array $value, $interfaceName) { if ($interfaceName == null) { $interfaceName = get_class($dataObject); } $returnType = $this->methodsMapProcessor->getMethodReturnType($interfaceName, $getterMethodName); if ($this->typeProcessor->isTypeSimple($returnType)) { $dataObject->{$methodName}($value); return $this; } if ($this->typeProcessor->isArrayType($returnType)) { $type = $this->typeProcessor->getArrayItemType($returnType); $objects = []; foreach ($value as $arrayElementData) { $object = $this->objectFactory->create($type, []); $this->populateWithArray($object, $arrayElementData, $type); $objects[] = $object; } $dataObject->{$methodName}($objects); return $this; } if (is_subclass_of($returnType, '\\Magento\\Framework\\Api\\ExtensibleDataInterface')) { $object = $this->objectFactory->create($returnType, []); $this->populateWithArray($object, $value, $returnType); } else { if (is_subclass_of($returnType, '\\Magento\\Framework\\Api\\ExtensionAttributesInterface')) { foreach ($value as $extensionAttributeKey => $extensionAttributeValue) { $extensionAttributeGetterMethodName = 'get' . \Magento\Framework\Api\SimpleDataObjectConverter::snakeCaseToUpperCamelCase($extensionAttributeKey); $methodReturnType = $this->methodsMapProcessor->getMethodReturnType($returnType, $extensionAttributeGetterMethodName); $extensionAttributeType = $this->typeProcessor->isArrayType($methodReturnType) ? $this->typeProcessor->getArrayItemType($methodReturnType) : $methodReturnType; if ($this->typeProcessor->isTypeSimple($extensionAttributeType)) { $value[$extensionAttributeKey] = $extensionAttributeValue; } else { if ($this->typeProcessor->isArrayType($methodReturnType)) { foreach ($extensionAttributeValue as $key => $extensionAttributeArrayValue) { $extensionAttribute = $this->objectFactory->create($extensionAttributeType, []); $this->populateWithArray($extensionAttribute, $extensionAttributeArrayValue, $extensionAttributeType); $value[$extensionAttributeKey][$key] = $extensionAttribute; } } else { $value[$extensionAttributeKey] = $this->objectFactory->create($extensionAttributeType, ['data' => $extensionAttributeValue]); } } } $object = $this->extensionFactory->create(get_class($dataObject), ['data' => $value]); } else { $object = $this->objectFactory->create($returnType, $value); } } $dataObject->{$methodName}($object); return $this; }
/** * @param array $typeData * @param array $expected * @dataProvider testGenerateDefinitionDataProvider */ public function testGenerateDefinition($typeData, $expected) { $getTypeData = function ($type) use($typeData) { return $typeData[$type]; }; $this->typeProcessorMock->method('getTypeData')->will($this->returnCallback($getTypeData)); $method = new \ReflectionMethod($this->generator, 'generateDefinition'); $method->setAccessible(true); $actual = $method->invoke($this->generator, key($typeData)); ksort($expected); ksort($actual); $this->assertSame(json_encode($expected), json_encode($actual)); }
/** * Process different element types. * * @param string $elementType * @param string $documentation * @param \DOMElement $appInfoNode * @return void */ protected function _processElementType($elementType, $documentation, \DOMElement $appInfoNode) { if ($elementType == 'int') { $this->_processRequiredAnnotation('min', $documentation, $appInfoNode); $this->_processRequiredAnnotation('max', $documentation, $appInfoNode); } if ($elementType == 'string') { $this->_processRequiredAnnotation('maxLength', $documentation, $appInfoNode); } if ($this->_typeProcessor->isArrayType($elementType)) { $natureOfTypeNode = $this->_getDom()->createElement(self::APP_INF_NS . ':natureOfType'); $natureOfTypeNode->appendChild($this->_getDom()->createTextNode('array')); $appInfoNode->appendChild($natureOfTypeNode); } }
/** * Test adding complex type with complex parameters and arrays. */ public function testAddComplexTypeComplexParameters() { $type = 'VendorModuleADataStructure'; $parameterType = 'ComplexType'; $typeData = ['documentation' => 'test', 'parameters' => ['complex_param' => ['type' => $parameterType, 'required' => true, 'documentation' => 'complex type param.']]]; $parameterData = ['documentation' => 'test', 'parameters' => ['string_param' => ['type' => 'ComplexTypeB[]', 'required' => true, 'documentation' => 'string param.']]]; $this->_wsdl->expects($this->at(0))->method('getTypes')->will($this->returnValue([])); $this->_wsdl->expects($this->any())->method('getTypes')->will($this->returnValue([$type => Wsdl::TYPES_NS . ':' . $type])); $this->_wsdl->expects($this->any())->method('toDomDocument')->will($this->returnValue(new \DOMDocument())); $schemaMock = $this->getMock('DOMElement', [], ['a']); $schemaMock->expects($this->any())->method('appendChild'); $this->_wsdl->expects($this->any())->method('getSchema')->will($this->returnValue($schemaMock)); $this->_typeProcessor->expects($this->at(0))->method('getTypeData')->with($type)->will($this->returnValue($typeData)); $this->_typeProcessor->expects($this->at(1))->method('getTypeData')->with($parameterType)->will($this->returnValue($parameterData)); $this->assertEquals(Wsdl::TYPES_NS . ':' . $type, $this->_strategy->addComplexType($type)); }
/** * Return routes loaded from cache if enabled or from files merged previously * * @return array */ public function getRoutesConfig() { if (null === $this->routes) { $routesConfig = $this->cache->load(self::ROUTES_CONFIG_CACHE_ID); $typesData = $this->cache->load(self::REFLECTED_TYPES_CACHE_ID); if ($routesConfig && is_string($routesConfig) && $typesData && is_string($typesData)) { $this->routes = unserialize($routesConfig); $this->typeProcessor->setTypesData(unserialize($typesData)); } else { $this->routes = $this->initRoutesMetadata(); $this->cache->save(serialize($this->routes), self::ROUTES_CONFIG_CACHE_ID); $this->cache->save(serialize($this->typeProcessor->getTypesData()), self::REFLECTED_TYPES_CACHE_ID); } } return $this->routes; }
/** * Add WSDL elements related to generic SOAP fault, which are common for all operations: element, type and message. * * @param Wsdl $wsdl * @return string Default fault message name */ protected function _addGenericFaultComplexTypeNodes($wsdl) { $faultMessageName = Fault::NODE_DETAIL_WRAPPER; $complexTypeName = $this->getElementComplexTypeName($faultMessageName); $wsdl->addElement(['name' => $faultMessageName, 'type' => Wsdl::TYPES_NS . ':' . $complexTypeName]); $faultParamsComplexType = Fault::NODE_DETAIL_PARAMETER; $faultParamsData = ['parameters' => [Fault::NODE_DETAIL_PARAMETER_KEY => ['type' => 'string', 'required' => true, 'documentation' => ''], Fault::NODE_DETAIL_PARAMETER_VALUE => ['type' => 'string', 'required' => true, 'documentation' => '']]]; $wrappedErrorComplexType = Fault::NODE_DETAIL_WRAPPED_ERROR; $wrappedErrorData = ['parameters' => [Fault::NODE_DETAIL_WRAPPED_ERROR_MESSAGE => ['type' => 'string', 'required' => true, 'documentation' => ''], Fault::NODE_DETAIL_WRAPPED_ERROR_PARAMETERS => ['type' => "{$faultParamsComplexType}[]", 'required' => false, 'documentation' => 'Message parameters.']]]; $genericFaultTypeData = ['parameters' => [Fault::NODE_DETAIL_TRACE => ['type' => 'string', 'required' => false, 'documentation' => 'Exception calls stack trace.'], Fault::NODE_DETAIL_PARAMETERS => ['type' => "{$faultParamsComplexType}[]", 'required' => false, 'documentation' => 'Additional exception parameters.'], Fault::NODE_DETAIL_WRAPPED_ERRORS => ['type' => "{$wrappedErrorComplexType}[]", 'required' => false, 'documentation' => 'Additional wrapped errors.']]]; $this->_typeProcessor->setTypeData($faultParamsComplexType, $faultParamsData); $this->_typeProcessor->setTypeData($wrappedErrorComplexType, $wrappedErrorData); $this->_typeProcessor->setTypeData($complexTypeName, $genericFaultTypeData); $wsdl->addComplexType($complexTypeName); $wsdl->addMessage($faultMessageName, ['messageParameters' => ['element' => Wsdl::TYPES_NS . ':' . $faultMessageName]]); return Wsdl::TYPES_NS . ':' . $faultMessageName; }
/** * Retrieve requested service method params metadata. * * @param string $serviceClassName * @param string $serviceMethodName * @return array */ protected function getMethodParams($serviceClassName, $serviceMethodName) { $cacheId = self::CACHE_ID_PREFIX . hash('md5', $serviceClassName . $serviceMethodName); $params = $this->cache->load($cacheId); if ($params !== false) { return unserialize($params); } $serviceClass = new ClassReflection($serviceClassName); /** @var MethodReflection $serviceMethod */ $serviceMethod = $serviceClass->getMethod($serviceMethodName); $params = []; /** @var ParameterReflection $paramReflection */ foreach ($serviceMethod->getParameters() as $paramReflection) { $isDefaultValueAvailable = $paramReflection->isDefaultValueAvailable(); $params[] = ['name' => $paramReflection->getName(), 'type' => $this->typeProcessor->getParamType($paramReflection), 'isDefaultValueAvailable' => $isDefaultValueAvailable, 'defaultValue' => $isDefaultValueAvailable ? $paramReflection->getDefaultValue() : null]; } $this->cache->save(serialize($params), $cacheId, [WebapiCache::CACHE_TAG]); return $params; }
/** * Use reflection to load the method information * * @param string $interfaceName * @return array */ private function getMethodMapViaReflection($interfaceName) { $methodMap = []; $class = new ClassReflection($interfaceName); $baseClassMethods = false; foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) { // Include all the methods of classes inheriting from AbstractExtensibleObject. // Ignore all the methods of AbstractExtensibleModel's parent classes if ($method->class === self::BASE_MODEL_CLASS) { $baseClassMethods = true; } elseif ($baseClassMethods) { // ReflectionClass::getMethods() sorts the methods by class (lowest in inheritance tree first) // then by the order they are defined in the class definition break; } if ($this->isSuitableMethod($method)) { $methodMap[$method->getName()] = $this->typeProcessor->getGetterReturnType($method); } } return $methodMap; }
/** * @param string $methodName * @param string $key * @param array $value * @return $this */ protected function setComplexValue($methodName, $key, array $value) { $returnType = $this->objectProcessor->getMethodReturnType($this->_getDataObjectType(), $methodName); if ($this->typeProcessor->isTypeSimple($returnType)) { $this->data[$key] = $value; return $this; } if ($this->typeProcessor->isArrayType($returnType)) { $type = $this->typeProcessor->getArrayItemType($returnType); $dataBuilder = $this->dataBuilderFactory->getDataBuilder($type); $objects = []; foreach ($value as $arrayElementData) { $objects[] = $dataBuilder->populateWithArray($arrayElementData)->create(); } $this->data[$key] = $objects; return $this; } $dataBuilder = $this->dataBuilderFactory->getDataBuilder($returnType); $object = $dataBuilder->populateWithArray($value)->create(); $this->data[$key] = $object; return $this; }
/** * Populate a specific attribute code with join directive instructions. * * @param string $attributeCode * @param array $directive * @param array &$data * @param array &$extensionData * @param string $extensibleEntityClass * @return void */ private function populateAttributeCodeWithDirective($attributeCode, $directive, &$data, &$extensionData, $extensibleEntityClass) { $attributeType = $directive[Converter::DATA_TYPE]; $selectFields = $this->joinProcessorHelper->getSelectFieldsMap($attributeCode, $directive[Converter::JOIN_FIELDS]); foreach ($selectFields as $selectField) { $internalAlias = $selectField[JoinDataInterface::SELECT_FIELD_INTERNAL_ALIAS]; if (isset($data[$internalAlias])) { if ($this->typeProcessor->isArrayType($attributeType)) { throw new \LogicException(sprintf('Join directives cannot be processed for attribute (%s) of extensible entity (%s),' . ' which has an Array type (%s).', $attributeCode, $this->extensionAttributesFactory->getExtensibleInterfaceName($extensibleEntityClass), $attributeType)); } elseif ($this->typeProcessor->isTypeSimple($attributeType)) { $extensionData['data'][$attributeCode] = $data[$internalAlias]; unset($data[$internalAlias]); break; } else { if (!isset($extensionData['data'][$attributeCode])) { $extensionData['data'][$attributeCode] = $this->objectManager->create($attributeType); } $setterName = $selectField[JoinDataInterface::SELECT_FIELD_SETTER]; $extensionData['data'][$attributeCode]->{$setterName}($data[$internalAlias]); unset($data[$internalAlias]); } } } }
/** * Set up helper. */ protected function setUp() { $this->_typeProcessor = $this->getMock('\\Magento\\Framework\\Reflection\\TypeProcessor', ['process'], [], '', false); $this->_typeProcessor->expects($this->any())->method('process')->will($this->returnValueMap([['string', 'str'], ['int', 'int']])); $this->_classReflector = new \Magento\Webapi\Model\Config\ClassReflector($this->_typeProcessor); }
/** * @expectedException \Magento\Framework\Exception\SerializationException * @expectedExceptionMessage Invalid type for value :"1". Expected Type: "int[]". */ public function testProcessSimpleTypeInvalidType() { $value = 1; $type = 'int[]'; $this->_typeProcessor->processSimpleAndAnyType($value, $type); }
/** * @expectedException \Exception * @expectedExceptionMessageRegExp /Property :"InvalidAttribute" does not exist in the provided class: \w+/ */ public function testFindSetterMethodNameInvalidAttribute() { $class = new ClassReflection("\\Magento\\Framework\\Reflection\\Test\\Unit\\DataObject"); $this->_typeProcessor->findSetterMethodName($class, 'InvalidAttribute'); }
public function testGetOperationName() { $this->assertEquals("resNameMethodName", $this->_typeProcessor->getOperationName("resName", "methodName")); }
/** * Retrieve method full documentation description. * * @param ReflectionMethod $method * @return string */ protected function extractMethodDescription(ReflectionMethod $method) { $methodReflection = new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()); $docBlock = $methodReflection->getDocBlock(); return $this->_typeProcessor->getDescription($docBlock); }