|
| 1 | +<?php |
| 2 | +/** |
| 3 | + * Copyright © Magento, Inc. All rights reserved. |
| 4 | + * See COPYING.txt for license details. |
| 5 | + */ |
| 6 | +namespace Magento\FunctionalTestingFramework\DataGenerator\Handlers; |
| 7 | + |
| 8 | +use Magento\FunctionalTestingFramework\DataGenerator\Objects\DataDefinition; |
| 9 | +use Magento\FunctionalTestingFramework\DataGenerator\Objects\DataElement; |
| 10 | +use Magento\FunctionalTestingFramework\DataGenerator\Parsers\OperationMetadataParser; |
| 11 | +use Magento\FunctionalTestingFramework\DataGenerator\Util\DataObjectExtractor; |
| 12 | +use Magento\FunctionalTestingFramework\ObjectManager\ObjectHandlerInterface; |
| 13 | +use Magento\FunctionalTestingFramework\ObjectManagerFactory; |
| 14 | + |
| 15 | +class DataDefinitionObjectHandler implements ObjectHandlerInterface |
| 16 | +{ |
| 17 | + const ENTITY_OPERATION_ROOT_TAG = 'operation'; |
| 18 | + const ENTITY_OPERATION_TYPE = 'type'; |
| 19 | + const ENTITY_OPERATION_DATA_TYPE = 'dataType'; |
| 20 | + const ENTITY_OPERATION_URL = 'url'; |
| 21 | + const ENTITY_OPERATION_METHOD = 'method'; |
| 22 | + const ENTITY_OPERATION_AUTH = 'auth'; |
| 23 | + const ENTITY_OPERATION_STORE_CODE = 'storeCode'; |
| 24 | + const ENTITY_OPERATION_SUCCESS_REGEX = 'successRegex'; |
| 25 | + const ENTITY_OPERATION_RETURN_REGEX = 'returnRegex'; |
| 26 | + const ENTITY_OPERATION_HEADER = 'header'; |
| 27 | + const ENTITY_OPERATION_HEADER_PARAM = 'param'; |
| 28 | + const ENTITY_OPERATION_HEADER_VALUE = 'value'; |
| 29 | + const ENTITY_OPERATION_URL_PARAM = 'param'; |
| 30 | + const ENTITY_OPERATION_URL_PARAM_TYPE = 'type'; |
| 31 | + const ENTITY_OPERATION_URL_PARAM_KEY = 'key'; |
| 32 | + const ENTITY_OPERATION_URL_PARAM_VALUE = 'value'; |
| 33 | + const ENTITY_OPERATION_ENTRY = 'entry'; |
| 34 | + const ENTITY_OPERATION_ENTRY_KEY = 'key'; |
| 35 | + const ENTITY_OPERATION_ENTRY_VALUE = 'value'; |
| 36 | + const ENTITY_OPERATION_ARRAY = 'array'; |
| 37 | + const ENTITY_OPERATION_ARRAY_KEY = 'key'; |
| 38 | + const ENTITY_OPERATION_ARRAY_VALUE = 'value'; |
| 39 | + const ENTITY_OPERATION_OBJECT = 'object'; |
| 40 | + const ENTITY_OPERATION_OBJECT_KEY = 'key'; |
| 41 | + const ENTITY_OPERATION_OBJECT_VALUE = 'value'; |
| 42 | + const ENTITY_OPERATION_DATA_OBJECT = 'metaDataObject'; |
| 43 | + |
| 44 | + /** |
| 45 | + * Singleton Instance of class |
| 46 | + * |
| 47 | + * @var DataDefinitionObjectHandler |
| 48 | + */ |
| 49 | + private static $DATA_DEFINITION_OBJECT_HANDLER; |
| 50 | + |
| 51 | + /** |
| 52 | + * Array containing all Data Definition Objects |
| 53 | + * |
| 54 | + * @var array |
| 55 | + */ |
| 56 | + private $dataDefinitions = []; |
| 57 | + |
| 58 | + /** |
| 59 | + * Object used to extract dataObjects from array into DataElements |
| 60 | + * |
| 61 | + * @var DataObjectExtractor |
| 62 | + */ |
| 63 | + private $dataDefExtractor; |
| 64 | + |
| 65 | + /** |
| 66 | + * Singleton method to return DataDefinitionProcessor. |
| 67 | + * |
| 68 | + * @return DataDefinitionObjectHandler |
| 69 | + */ |
| 70 | + public static function getInstance() |
| 71 | + { |
| 72 | + if (!self::$DATA_DEFINITION_OBJECT_HANDLER) { |
| 73 | + self::$DATA_DEFINITION_OBJECT_HANDLER = new DataDefinitionObjectHandler(); |
| 74 | + self::$DATA_DEFINITION_OBJECT_HANDLER->initDataDefinitions(); |
| 75 | + } |
| 76 | + |
| 77 | + return self::$DATA_DEFINITION_OBJECT_HANDLER; |
| 78 | + } |
| 79 | + |
| 80 | + /** |
| 81 | + * Returns a DataDefinition object based on name |
| 82 | + * |
| 83 | + * @param string $dataDefinitionName |
| 84 | + * @return DataDefinition |
| 85 | + */ |
| 86 | + public function getObject($dataDefinitionName) |
| 87 | + { |
| 88 | + return $this->dataDefinitions[$dataDefinitionName]; |
| 89 | + } |
| 90 | + |
| 91 | + /** |
| 92 | + * Returns all data Definition objects |
| 93 | + * |
| 94 | + * @return array |
| 95 | + */ |
| 96 | + public function getAllObjects() |
| 97 | + { |
| 98 | + return $this->dataDefinitions; |
| 99 | + } |
| 100 | + |
| 101 | + /** |
| 102 | + * DataDefintionArrayProcessor constructor. |
| 103 | + */ |
| 104 | + private function __construct() |
| 105 | + { |
| 106 | + $this->dataDefExtractor = new DataObjectExtractor(); |
| 107 | + } |
| 108 | + |
| 109 | + /** |
| 110 | + * This method takes an operation such as create and a data type such as 'customer' and returns the corresponding |
| 111 | + * data definition defined in metadata.xml |
| 112 | + * |
| 113 | + * @param string $operation |
| 114 | + * @param string $dataType |
| 115 | + * @return DataDefinition |
| 116 | + */ |
| 117 | + public function getDataDefinition($operation, $dataType) |
| 118 | + { |
| 119 | + return $this->getObject($operation . $dataType); |
| 120 | + } |
| 121 | + |
| 122 | + /** |
| 123 | + * This method reads all dataDefinitions from metadata xml into memory. |
| 124 | + * @return void |
| 125 | + */ |
| 126 | + private function initDataDefinitions() |
| 127 | + { |
| 128 | + $objectManager = ObjectManagerFactory::getObjectManager(); |
| 129 | + $metadataParser = $objectManager->create(OperationMetadataParser::class); |
| 130 | + foreach ($metadataParser->readOperationMetadata()[DataDefinitionObjectHandler::ENTITY_OPERATION_ROOT_TAG] as |
| 131 | + $dataDefName => $dataDefArray) { |
| 132 | + $operation = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_TYPE]; |
| 133 | + $dataType = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_DATA_TYPE]; |
| 134 | + $url = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_URL] ?? null; |
| 135 | + $method = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_METHOD] ?? null; |
| 136 | + $auth = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_AUTH] ?? null; |
| 137 | + $storeCode = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_STORE_CODE] ?? null; |
| 138 | + $successRegex = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_SUCCESS_REGEX] ?? null; |
| 139 | + $returnRegex = $dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_RETURN_REGEX] ?? null; |
| 140 | + $headers = []; |
| 141 | + $params = []; |
| 142 | + $metaData = []; |
| 143 | + |
| 144 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER, $dataDefArray)) { |
| 145 | + foreach ($dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER] as $headerEntry) { |
| 146 | + if (isset($headerEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER_VALUE]) |
| 147 | + && $headerEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER_VALUE] !== 'none') { |
| 148 | + $headers[] = $headerEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER_PARAM] . ': ' . |
| 149 | + $headerEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_HEADER_VALUE]; |
| 150 | + } |
| 151 | + } |
| 152 | + } |
| 153 | + |
| 154 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_URL_PARAM, $dataDefArray)) { |
| 155 | + foreach ($dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_URL_PARAM] as $paramEntry) { |
| 156 | + $params[$paramEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_URL_PARAM_TYPE]] |
| 157 | + [$paramEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_URL_PARAM_KEY]] = |
| 158 | + $paramEntry[DataDefinitionObjectHandler::ENTITY_OPERATION_URL_PARAM_VALUE]; |
| 159 | + } |
| 160 | + } |
| 161 | + |
| 162 | + // extract relevant dataObjects as DataElements |
| 163 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_DATA_OBJECT, $dataDefArray)) { |
| 164 | + foreach ($dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_DATA_OBJECT] as $dataObjectArray) { |
| 165 | + $metaData[] = $this->dataDefExtractor->extractDataObject($dataObjectArray); |
| 166 | + } |
| 167 | + } |
| 168 | + |
| 169 | + //handle loose entries |
| 170 | + |
| 171 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_ENTRY, $dataDefArray)) { |
| 172 | + foreach ($dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_ENTRY] as $dataEntryType) { |
| 173 | + $metaData[] = new DataElement( |
| 174 | + $dataEntryType[DataDefinitionObjectHandler::ENTITY_OPERATION_ENTRY_KEY], |
| 175 | + $dataEntryType[DataDefinitionObjectHandler::ENTITY_OPERATION_ENTRY_VALUE], |
| 176 | + DataDefinitionObjectHandler::ENTITY_OPERATION_ENTRY |
| 177 | + ); |
| 178 | + } |
| 179 | + } |
| 180 | + |
| 181 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY, $dataDefArray)) { |
| 182 | + foreach ($dataDefArray[DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY] as $dataEntryType) { |
| 183 | + $subMetaData = []; |
| 184 | + $value = null; |
| 185 | + $type = null; |
| 186 | + |
| 187 | + if (array_key_exists(DataDefinitionObjectHandler::ENTITY_OPERATION_DATA_OBJECT, $dataEntryType)) { |
| 188 | + $nestedDataElement = $this->dataDefExtractor->extractDataObject( |
| 189 | + $dataEntryType[DataDefinitionObjectHandler::ENTITY_OPERATION_DATA_OBJECT][0] |
| 190 | + ); |
| 191 | + $subMetaData[$nestedDataElement->getKey()] = $nestedDataElement; |
| 192 | + $value = $nestedDataElement->getValue(); |
| 193 | + $type = $nestedDataElement->getKey(); |
| 194 | + } else { |
| 195 | + $value = $dataEntryType[DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY_VALUE][0] |
| 196 | + [DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY_VALUE]; |
| 197 | + $type = [DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY_VALUE]; |
| 198 | + } |
| 199 | + |
| 200 | + $metaData[] = new DataElement( |
| 201 | + $dataEntryType[DataDefinitionObjectHandler::ENTITY_OPERATION_ARRAY_KEY], |
| 202 | + $value, |
| 203 | + $type, |
| 204 | + $subMetaData |
| 205 | + ); |
| 206 | + } |
| 207 | + } |
| 208 | + |
| 209 | + $this->dataDefinitions[$operation . $dataType] = new DataDefinition( |
| 210 | + $dataDefName, |
| 211 | + $operation, |
| 212 | + $dataType, |
| 213 | + $method, |
| 214 | + $url, |
| 215 | + $auth, |
| 216 | + $headers, |
| 217 | + $params, |
| 218 | + $metaData, |
| 219 | + $successRegex, |
| 220 | + $returnRegex, |
| 221 | + $storeCode |
| 222 | + ); |
| 223 | + } |
| 224 | + } |
| 225 | +} |
0 commit comments