DataObjectHandler.php

Go to the documentation of this file.

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

use Magento\FunctionalTestingFramework\DataGenerator\Objects\EntityDataObject;
use Magento\FunctionalTestingFramework\DataGenerator\Parsers\DataProfileSchemaParser;
use Magento\FunctionalTestingFramework\Exceptions\XmlException;
use Magento\FunctionalTestingFramework\ObjectManager\ObjectHandlerInterface;
use Magento\FunctionalTestingFramework\ObjectManagerFactory;
use Magento\FunctionalTestingFramework\DataGenerator\Util\DataExtensionUtil;

class DataObjectHandler implements ObjectHandlerInterface
{
    const _ENTITY = 'entity';
    const _NAME = 'name';
    const _TYPE = 'type';
    const _EXTENDS = 'extends';
    const _DATA = 'data';
    const _KEY = 'key';
    const _VALUE = 'value';
    const _UNIQUE = 'unique';
    const _PREFIX = 'prefix';
    const _SUFFIX = 'suffix';
    const _ARRAY = 'array';
    const _ITEM = 'item';
    const _VAR = 'var';
    const _ENTITY_TYPE = 'entityType';
    const _ENTITY_KEY = 'entityKey';
    const _SEPARATOR = '->';
    const _REQUIRED_ENTITY = 'requiredEntity';
    const DATA_NAME_ERROR_MSG = "Entity names cannot contain non alphanumeric characters.\tData='%s'";

    private static $INSTANCE;

    private $entityDataObjects = [];

    private $extendUtil;

    private function __construct()
    {
        $parser = ObjectManagerFactory::getObjectManager()->create(DataProfileSchemaParser::class);
        $parserOutput = $parser->readDataProfiles();
        if (!$parserOutput) {
            return;
        }
        $this->entityDataObjects = $this->processParserOutput($parserOutput);
        $this->extendUtil = new DataExtensionUtil();
    }

    public static function getInstance()
    {
        if (!self::$INSTANCE) {
            self::$INSTANCE = new DataObjectHandler();
        }
        return self::$INSTANCE;
    }

    public function getObject($name)
    {
        if (array_key_exists($name, $this->entityDataObjects)) {
            return $this->extendDataObject($this->entityDataObjects[$name]);
        }

        return null;
    }

    public function getAllObjects()
    {
        foreach ($this->entityDataObjects as $entityName => $entityObject) {
            $this->entityDataObjects[$entityName] = $this->extendDataObject($entityObject);
        }
        return $this->entityDataObjects;
    }

    private function processParserOutput($parserOutput)
    {
        $entityDataObjects = [];
        $rawEntities = $parserOutput[self::_ENTITY];

        foreach ($rawEntities as $name => $rawEntity) {
            if (preg_match('/[^a-zA-Z0-9_]/', $name)) {
                throw new XmlException(sprintf(self::DATA_NAME_ERROR_MSG, $name));
            }

            $type = $rawEntity[self::_TYPE] ?? null;
            $data = [];
            $linkedEntities = [];
            $uniquenessData = [];
            $vars = [];
            $parentEntity = null;

            if (array_key_exists(self::_DATA, $rawEntity)) {
                $data = $this->processDataElements($rawEntity);
                $uniquenessData = $this->processUniquenessData($rawEntity);
            }

            if (array_key_exists(self::_REQUIRED_ENTITY, $rawEntity)) {
                $linkedEntities = $this->processLinkedEntities($rawEntity);
            }

            if (array_key_exists(self::_ARRAY, $rawEntity)) {
                $arrays = $rawEntity[self::_ARRAY];
                foreach ($arrays as $array) {
                    $key = strtolower($array[self::_KEY]);
                    $data[$key] = $this->processArray($array[self::_ITEM], $data, $key);
                }
            }

            if (array_key_exists(self::_VAR, $rawEntity)) {
                $vars = $this->processVarElements($rawEntity);
            }

            if (array_key_exists(self::_EXTENDS, $rawEntity)) {
                $parentEntity = $rawEntity[self::_EXTENDS];
            }

            $entityDataObject = new EntityDataObject(
                $name,
                $type,
                $data,
                $linkedEntities,
                $uniquenessData,
                $vars,
                $parentEntity
            );

            $entityDataObjects[$entityDataObject->getName()] = $entityDataObject;
        }

        return $entityDataObjects;
    }

    private function processArray($arrayItems, $data, $key)
    {
        $items = [];
        foreach ($arrayItems as $item) {
            $items[] = $item[self::_VALUE];
        }

        return array_merge($items, $data[$key] ?? []);
    }

    private function processDataElements($entityData)
    {
        $dataValues = [];
        foreach ($entityData[self::_DATA] as $dataElement) {
            $dataElementKey = strtolower($dataElement[self::_KEY]);
            $dataElementValue = $dataElement[self::_VALUE] ?? "";
            $dataValues[$dataElementKey] = $dataElementValue;
        }
        return $dataValues;
    }

    private function processUniquenessData($entityData)
    {
        $uniquenessValues = [];
        foreach ($entityData[self::_DATA] as $dataElement) {
            if (array_key_exists(self::_UNIQUE, $dataElement)) {
                $dataElementKey = strtolower($dataElement[self::_KEY]);
                $uniquenessValues[$dataElementKey] = $dataElement[self::_UNIQUE];
            }
        }
        return $uniquenessValues;
    }

    private function processLinkedEntities($entityData)
    {
        $linkedEntities = [];
        foreach ($entityData[self::_REQUIRED_ENTITY] as $linkedEntity) {
            $linkedEntityName = $linkedEntity[self::_VALUE];
            $linkedEntityType = $linkedEntity[self::_TYPE];

            $linkedEntities[$linkedEntityName] = $linkedEntityType;
        }
        return $linkedEntities;
    }

    private function processVarElements($entityData)
    {
        $vars = [];
        foreach ($entityData[self::_VAR] as $varElement) {
            $varKey = $varElement[self::_KEY];
            $varValue = $varElement[self::_ENTITY_TYPE] . self::_SEPARATOR . $varElement[self::_ENTITY_KEY];
            $vars[$varKey] = $varValue;
        }
        return $vars;
    }

    private function extendDataObject($dataObject)
    {
        if ($dataObject->getParentName() != null) {
            return $this->extendUtil->extendEntity($dataObject);
        }
        return $dataObject;
    }
}