OperationDataArrayResolver.php

Go to the documentation of this file.

<?php
namespace Magento\FunctionalTestingFramework\DataGenerator\Persist;

use Magento\FunctionalTestingFramework\DataGenerator\Handlers\DataObjectHandler;
use Magento\FunctionalTestingFramework\DataGenerator\Handlers\OperationDefinitionObjectHandler;
use Magento\FunctionalTestingFramework\DataGenerator\Objects\EntityDataObject;
use Magento\FunctionalTestingFramework\DataGenerator\Objects\OperationElement;
use Magento\FunctionalTestingFramework\DataGenerator\Util\OperationElementExtractor;
use Magento\FunctionalTestingFramework\Exceptions\TestFrameworkException;

class OperationDataArrayResolver
{
    const PRIMITIVE_TYPES = [
        'string',
        'boolean',
        'integer',
        'number'
    ];
    const EXCEPTION_REQUIRED_DATA = "%s of key \" %s\" in \"%s\" is required by metadata, but was not provided.";

    private static $entitySequences = [];

    private $dependentEntities = [];

    public function __construct($dependentEntities = null)
    {
        if ($dependentEntities !== null) {
            foreach ($dependentEntities as $entity) {
                $this->dependentEntities[$entity->getName()] = $entity;
            }
        }
    }

    public function resolveOperationDataArray($entityObject, $operationMetadata, $operation, $fromArray = false)
    {
        //TODO: Refactor to reduce Cyclomatic Complexity, remove SupressWarning accordingly.
        $operationDataArray = [];
        self::incrementSequence($entityObject->getName());

        foreach ($operationMetadata as $operationElement) {
            if ($operationElement->getType() == OperationElementExtractor::OPERATION_OBJECT_OBJ_NAME) {
                $entityObj = $this->resolveOperationObjectAndEntityData($entityObject, $operationElement->getValue());
                if (null === $entityObj && $operationElement->isRequired()) {
                    throw new \Exception(sprintf(
                        self::EXCEPTION_REQUIRED_DATA,
                        $operationElement->getType(),
                        $operationElement->getKey(),
                        $entityObject->getName()
                    ));
                } elseif (null === $entityObj) {
                    continue;
                }
                $operationData = $this->resolveOperationDataArray(
                    $entityObj,
                    $operationElement->getNestedMetadata(),
                    $operation,
                    $fromArray
                );
                if (!$fromArray) {
                    $operationDataArray[$operationElement->getKey()] = $operationData;
                } else {
                    $operationDataArray = $operationData;
                }
                continue;
            }

            $operationElementType = $operationElement->getValue();

            if (in_array($operationElementType, self::PRIMITIVE_TYPES)) {
                $elementData = $this->resolvePrimitiveReference(
                    $entityObject,
                    $operationElement->getKey(),
                    $operationElement->getType()
                );

                // If data was defined at all, attempt to put it into operation data array
                // If data was not defined, and element is required, throw exception
                // If no data is defined, don't input defaults per primitive into operation data array
                if ($elementData != null) {
                    if (array_key_exists($operationElement->getKey(), $entityObject->getUniquenessData())) {
                        $uniqueData = $entityObject->getUniquenessDataByName($operationElement->getKey());
                        if ($uniqueData === 'suffix') {
                            $elementData .= (string)self::getSequence($entityObject->getName());
                        } else {
                            $elementData = (string)self::getSequence($entityObject->getName()) . $elementData;
                        }
                    }
                    $operationDataArray[$operationElement->getKey()] = $this->castValue(
                        $operationElementType,
                        $elementData
                    );
                } elseif ($operationElement->isRequired()) {
                    throw new \Exception(sprintf(
                        self::EXCEPTION_REQUIRED_DATA,
                        $operationElement->getType(),
                        $operationElement->getKey(),
                        $entityObject->getName()
                    ));
                }
            } else {
                $entityNamesOfType = $entityObject->getLinkedEntitiesOfType($operationElementType);

                // If an element is required by metadata, but was not provided in the entity, throw an exception
                if ($operationElement->isRequired() && $entityNamesOfType == null) {
                    throw new \Exception(sprintf(
                        self::EXCEPTION_REQUIRED_DATA,
                        $operationElement->getType(),
                        $operationElement->getKey(),
                        $entityObject->getName()
                    ));
                }
                foreach ($entityNamesOfType as $entityName) {
                    $operationDataSubArray = $this->resolveNonPrimitiveElement(
                        $entityName,
                        $operationElement,
                        $operation,
                        $fromArray
                    );

                    if ($operationElement->getType() == OperationDefinitionObjectHandler::ENTITY_OPERATION_ARRAY) {
                        $operationDataArray[$operationElement->getKey()][] = $operationDataSubArray;
                    } else {
                        $operationDataArray[$operationElement->getKey()] = $operationDataSubArray;
                    }
                }
            }
        }

        return $operationDataArray;
    }

    private function resolvePrimitiveReference($entityObject, $operationKey, $operationElementType)
    {
        $elementData = $entityObject->getDataByName(
            $operationKey,
            EntityDataObject::CEST_UNIQUE_VALUE
        );

        if ($elementData == null && $entityObject->getVarReference($operationKey) != null) {
            list($type, $field) = explode(
                DataObjectHandler::_SEPARATOR,
                $entityObject->getVarReference($operationKey)
            );

            if ($operationElementType == OperationDefinitionObjectHandler::ENTITY_OPERATION_ARRAY) {
                $elementDatas = [];
                $entities = $this->getDependentEntitiesOfType($type);
                foreach ($entities as $entity) {
                    $elementDatas[] = $entity->getDataByName($field, EntityDataObject::CEST_UNIQUE_VALUE);
                }

                return $elementDatas;
            }

            $entity = $this->getDependentEntitiesOfType($type)[0];
            $elementData = $entity->getDataByName($field, EntityDataObject::CEST_UNIQUE_VALUE);
        }

        return $elementData;
    }

    private function getDependentEntitiesOfType($type)
    {
        $entitiesOfType = [];

        foreach ($this->dependentEntities as $dependentEntity) {
            if ($dependentEntity->getType() == $type) {
                $entitiesOfType[] = $dependentEntity;
            }
        }

        return $entitiesOfType;
    }

    private function resolveOperationObjectAndEntityData($entityObject, $operationElementValue)
    {
        if ($operationElementValue != $entityObject->getType()) {
            // if we have a mismatch attempt to retrieve linked data and return just the first linkage
            $linkName = $entityObject->getLinkedEntitiesOfType($operationElementValue);
            if (!empty($linkName)) {
                $linkName = $linkName[0];
                return DataObjectHandler::getInstance()->getObject($linkName);
            }
            return null;
        }

        return $entityObject;
    }

    private function resolveNonPrimitiveElement($entityName, $operationElement, $operation, $fromArray = false)
    {
        $linkedEntityObj = $this->resolveLinkedEntityObject($entityName);

        // in array case
        if (!empty($operationElement->getNestedOperationElement($operationElement->getValue()))
            && $operationElement->getType() == OperationDefinitionObjectHandler::ENTITY_OPERATION_ARRAY
        ) {
            $operationSubArray = $this->resolveOperationDataArray(
                $linkedEntityObj,
                [$operationElement->getNestedOperationElement($operationElement->getValue())],
                $operation,
                true
            );

            return $operationSubArray;
        }

        $operationMetadata = OperationDefinitionObjectHandler::getInstance()->getOperationDefinition(
            $operation,
            $linkedEntityObj->getType()
        )->getOperationMetadata();

        return $this->resolveOperationDataArray($linkedEntityObj, $operationMetadata, $operation, $fromArray);
    }

    private function resolveLinkedEntityObject($entityName)
    {
        // check our dependent entity list to see if we have this defined
        if (array_key_exists($entityName, $this->dependentEntities)) {
            return $this->dependentEntities[$entityName];
        }

        return DataObjectHandler::getInstance()->getObject($entityName);
    }

    private static function incrementSequence($entityName)
    {
        if (array_key_exists($entityName, self::$entitySequences)) {
            self::$entitySequences[$entityName]++;
        } else {
            self::$entitySequences[$entityName] = 1;
        }
    }

    private static function getSequence($entityName)
    {
        if (array_key_exists($entityName, self::$entitySequences)) {
            return self::$entitySequences[$entityName];
        }
        return 0;
    }

    // @codingStandardsIgnoreStart
    private function castValue($type, $value)
    {
        $newVal = $value;

        if (is_array($value)) {
            $newVals = [];
            foreach($value as $val) {
                $newVals[] = $this->castValue($type, $val);
            }

            return $newVals;
        }

        switch ($type) {
            case 'string':
                break;
            case 'integer':
                $newVal = (integer)$value;
                break;
            case 'boolean':
                if (strtolower($newVal) === 'false') {
                    return false;
                }
                $newVal = (boolean)$value;
                break;
            case 'number':
                $newVal = (float)$value;
                break;
        }

        return $newVal;
    }
    // @codingStandardsIgnoreEnd
}