ActionObject.php

Go to the documentation of this file.

<?php
namespace Magento\FunctionalTestingFramework\Test\Objects;

use Magento\FunctionalTestingFramework\Config\MftfApplicationConfig;
use Magento\FunctionalTestingFramework\DataGenerator\Handlers\DataObjectHandler;
use Magento\FunctionalTestingFramework\DataGenerator\Objects\EntityDataObject;
use Magento\FunctionalTestingFramework\Exceptions\XmlException;
use Magento\FunctionalTestingFramework\ObjectManager\ObjectHandlerInterface;
use Magento\FunctionalTestingFramework\Page\Objects\PageObject;
use Magento\FunctionalTestingFramework\Page\Objects\SectionObject;
use Magento\FunctionalTestingFramework\Page\Handlers\PageObjectHandler;
use Magento\FunctionalTestingFramework\Page\Handlers\SectionObjectHandler;
use Magento\FunctionalTestingFramework\Exceptions\TestReferenceException;
use Magento\FunctionalTestingFramework\Util\Logger\LoggingUtil;

class ActionObject
{
    const __ENV = "_ENV";
    const __CREDS = "_CREDS";
    const RUNTIME_REFERENCES = [
        self::__ENV,
        self::__CREDS
    ];

    const DATA_ENABLED_ATTRIBUTES = [
        "userInput",
        "parameterArray",
        "expected",
        "actual",
        "x",
        "y",
        "expectedResult",
        "actualResult",
        "command",
        "regex",
        "date",
        "format"
    ];
    const SELECTOR_ENABLED_ATTRIBUTES = [
        'selector',
        'dependentSelector',
        "selector1",
        "selector2",
        "function",
        'filterSelector',
        'optionSelector',
        "command"
    ];
    const OLD_ASSERTION_ATTRIBUTES = ["expected", "expectedType", "actual", "actualType"];
    const ASSERTION_ATTRIBUTES = ["expectedResult" => "expected", "actualResult" => "actual"];
    const ASSERTION_TYPE_ATTRIBUTE = "type";
    const ASSERTION_VALUE_ATTRIBUTE = "value";
    const DELETE_DATA_MUTUAL_EXCLUSIVE_ATTRIBUTES = ["url", "createDataKey"];
    const EXTERNAL_URL_AREA_INVALID_ACTIONS = ['amOnPage'];
    const FUNCTION_CLOSURE_ACTIONS = ['waitForElementChange', 'performOn'];
    const MERGE_ACTION_ORDER_AFTER = 'after';
    const MERGE_ACTION_ORDER_BEFORE = 'before';
    const ACTION_ATTRIBUTE_TIMEZONE = 'timezone';
    const ACTION_ATTRIBUTE_URL = 'url';
    const ACTION_ATTRIBUTE_SELECTOR = 'selector';
    const ACTION_ATTRIBUTE_VARIABLE_REGEX_PARAMETER = '/\(.+\)/';
    const ACTION_ATTRIBUTE_VARIABLE_REGEX_PATTERN = '/({{[\w]+\.[\w\[\]]+}})|({{[\w]+\.[\w]+\((?(?!}}).)+\)}})/';

    private $stepKey;

    private $type;

    private $actionAttributes = [];

    private $linkedAction;

    private $orderOffset = 0;

    private $resolvedCustomAttributes = [];

    private $timeout;

    private $actionOrigin = [];

    public function __construct(
        $stepKey,
        $type,
        $actionAttributes,
        $linkedAction = null,
        $order = ActionObject::MERGE_ACTION_ORDER_BEFORE,
        $actionOrigin = null
    ) {
        $this->stepKey = $stepKey;
        $this->type = $type;
        $this->actionAttributes = $actionAttributes;
        $this->linkedAction = $linkedAction;
        $this->actionOrigin = $actionOrigin;

        if ($order == ActionObject::MERGE_ACTION_ORDER_AFTER) {
            $this->orderOffset = 1;
        }
    }

    public function getStepKey()
    {
        return $this->stepKey;
    }

    public function getType()
    {
        return $this->type;
    }

    public function getActionOrigin()
    {
        return $this->actionOrigin;
    }

    public function getCustomActionAttributes()
    {
        return array_merge($this->actionAttributes, $this->resolvedCustomAttributes);
    }

    public function getLinkedAction()
    {
        return $this->linkedAction;
    }

    public function getOrderOffset()
    {
        return $this->orderOffset;
    }

    public function getTimeout()
    {
        return $this->timeout;
    }

    public function setTimeout($timeout)
    {
        $this->timeout = $timeout;
    }

    public function resolveReferences()
    {
        if (empty($this->resolvedCustomAttributes)) {
            $this->trimAssertionAttributes();
            $this->resolveSelectorReferenceAndTimeout();
            $this->resolveUrlReference();
            $this->resolveDataInputReferences();
            $this->validateTimezoneAttribute();
            if ($this->getType() == "deleteData") {
                $this->validateMutuallyExclusiveAttributes(self::DELETE_DATA_MUTUAL_EXCLUSIVE_ATTRIBUTES);
            }
        }
    }

    public function trimAssertionAttributes()
    {
        $actionAttributeKeys = array_keys($this->actionAttributes);

        $oldAttributes = array_intersect($actionAttributeKeys, ActionObject::OLD_ASSERTION_ATTRIBUTES);
        if (!empty($oldAttributes)) {
            $appConfig = MftfApplicationConfig::getConfig();
            if ($appConfig->getPhase() == MftfApplicationConfig::GENERATION_PHASE && $appConfig->verboseEnabled()) {
                LoggingUtil::getInstance()->getLogger(ActionObject::class)->deprecation(
                    "use of one line Assertion actions will be deprecated in MFTF 3.0.0, please use nested syntax",
                    ["action" => $this->type, "stepKey" => $this->stepKey]
                );
            }
            return;
        }

        $relevantKeys = array_keys(ActionObject::ASSERTION_ATTRIBUTES);
        $relevantAssertionAttributes = array_intersect($actionAttributeKeys, $relevantKeys);

        if (empty($relevantAssertionAttributes)) {
            return;
        }

        $this->validateAssertionSchema($relevantAssertionAttributes);

        // Flatten nested Elements's type and value into key=>value entries
        foreach ($this->actionAttributes as $key => $subAttributes) {
            if (in_array($key, $relevantKeys)) {
                $prefix = ActionObject::ASSERTION_ATTRIBUTES[$key];
                $this->actionAttributes[$prefix . ucfirst(ActionObject::ASSERTION_TYPE_ATTRIBUTE)] =
                    $subAttributes[ActionObject::ASSERTION_TYPE_ATTRIBUTE];
                $this->actionAttributes[$prefix] =
                    $subAttributes[ActionObject::ASSERTION_VALUE_ATTRIBUTE];
                unset($this->actionAttributes[$key]);
            }
        }
    }

    private function validateAssertionSchema($attributes)
    {
        $singleChildTypes = ['assertEmpty', 'assertFalse', 'assertFileExists', 'assertFileNotExists',
            'assertIsEmpty', 'assertNotEmpty', 'assertNotNull', 'assertNull', 'assertTrue',
            'assertElementContainsAttribute'];

        if (!in_array($this->type, $singleChildTypes)) {
            if (!in_array('expectedResult', $attributes)
                || !in_array('actualResult', $attributes)) {
                throw new TestReferenceException(
                    "{$this->type} must have both an expectedResult & actualResult defined (stepKey: {$this->stepKey})",
                    ["action" => $this->type, "stepKey" => $this->stepKey]
                );
            }
        }
    }

    private function resolveSelectorReferenceAndTimeout()
    {
        $actionAttributeKeys = array_keys($this->actionAttributes);
        $relevantSelectorAttributes = array_intersect($actionAttributeKeys, ActionObject::SELECTOR_ENABLED_ATTRIBUTES);

        if (empty($relevantSelectorAttributes)) {
            return;
        }

        foreach ($relevantSelectorAttributes as $selectorAttribute) {
            $selector = $this->actionAttributes[$selectorAttribute];

            $replacement = $this->findAndReplaceReferences(SectionObjectHandler::getInstance(), $selector);
            if ($replacement) {
                $this->resolvedCustomAttributes[$selectorAttribute] = $replacement;
            }
        }
    }

    private function resolveUrlReference()
    {
        if (!array_key_exists(ActionObject::ACTION_ATTRIBUTE_URL, $this->actionAttributes)) {
            return;
        }

        $url = $this->actionAttributes[ActionObject::ACTION_ATTRIBUTE_URL];

        $replacement = $this->findAndReplaceReferences(PageObjectHandler::getInstance(), $url);
        if ($replacement) {
            $this->resolvedCustomAttributes[ActionObject::ACTION_ATTRIBUTE_URL] = $replacement;
            $allPages = PageObjectHandler::getInstance()->getAllObjects();
            if ($replacement === $url && array_key_exists(trim($url, "{}"), $allPages)
            ) {
                LoggingUtil::getInstance()->getLogger(ActionObject::class)->warning(
                    "page url attribute not found and is required",
                    ["action" => $this->type, "url" => $url, "stepKey" => $this->stepKey]
                );
            }
        }
    }

    private function resolveDataInputReferences()
    {
        $actionAttributeKeys = array_keys($this->actionAttributes);
        $relevantDataAttributes = array_intersect($actionAttributeKeys, ActionObject::DATA_ENABLED_ATTRIBUTES);

        if (empty($relevantDataAttributes)) {
            return;
        }

        foreach ($relevantDataAttributes as $dataAttribute) {
            $varInput = $this->actionAttributes[$dataAttribute];
            $replacement = $this->findAndReplaceReferences(DataObjectHandler::getInstance(), $varInput);
            if ($replacement !== null) {
                $this->resolvedCustomAttributes[$dataAttribute] = $replacement;
            }
        }
    }

    private function stripAndSplitReference($reference)
    {
        $strippedReference = str_replace('}}', '', str_replace('{{', '', $reference));
        $strippedReference = preg_replace(
            ActionObject::ACTION_ATTRIBUTE_VARIABLE_REGEX_PARAMETER,
            '',
            $strippedReference
        );
        return explode('.', $strippedReference);
    }

    private function stripAndReturnParameters($reference)
    {
        // 'string', or 'string,!@#$%^&*()_+, '
        $literalParametersRegex = "/'[^']+'/";
        $postCleanupDelimiter = "::::";

        preg_match(ActionObject::ACTION_ATTRIBUTE_VARIABLE_REGEX_PARAMETER, $reference, $matches);
        if (!empty($matches)) {
            $strippedReference = ltrim(rtrim($matches[0], ")"), "(");

            // Pull out all 'string' references, as they can contain 'string with , comma in it'
            preg_match_all($literalParametersRegex, $strippedReference, $literalReferences);
            $strippedReference = preg_replace($literalParametersRegex, '&&stringReference&&', $strippedReference);

            // Sanitize 'string, data.field,$persisted.field$' => 'string::::data.field::::$persisted.field$'
            $strippedReference = preg_replace('/,/', ', ', $strippedReference);
            $strippedReference = str_replace(',', $postCleanupDelimiter, $strippedReference);
            $strippedReference = str_replace(' ', '', $strippedReference);

            // Replace string references into string, needed to keep sequence
            foreach ($literalReferences[0] as $key => $value) {
                $strippedReference = preg_replace('/&&stringReference&&/', $value, $strippedReference, 1);
            }

            return explode($postCleanupDelimiter, $strippedReference);
        }
        return null;
    }

    private function findAndReplaceReferences($objectHandler, $inputString)
    {
        //look for parameter area, if so use different regex
        $regex = ActionObject::ACTION_ATTRIBUTE_VARIABLE_REGEX_PATTERN;

        preg_match_all($regex, $inputString, $matches);

        $outputString = $inputString;

        foreach ($matches[0] as $match) {
            $replacement = null;
            $parameterized = false;
            list($objName) = $this->stripAndSplitReference($match);

            $obj = $objectHandler->getObject($objName);

            // Leave runtime references to be replaced in TestGenerator with getter function accessing "VARIABLE"
            if (in_array($objName, ActionObject::RUNTIME_REFERENCES)) {
                continue;
            }

            if ($obj == null) {
                // keep initial values for subsequent logic
                $replacement = null;
                $parameterized = false;
            } elseif (get_class($obj) == PageObject::class) {
                $this->validateUrlAreaAgainstActionType($obj);
                $replacement = $obj->getUrl();
                $parameterized = $obj->isParameterized();
            } elseif (get_class($obj) == SectionObject::class) {
                list(,$objField) = $this->stripAndSplitReference($match);
                if ($obj->getElement($objField) == null) {
                    throw new TestReferenceException(
                        "Could not resolve entity reference \"{$inputString}\" "
                        . "in Action with stepKey \"{$this->getStepKey()}\"",
                        ["input" => $inputString, "stepKey" => $this->getStepKey()]
                    );
                }
                $parameterized = $obj->getElement($objField)->isParameterized();
                $replacement = $obj->getElement($objField)->getPrioritizedSelector();
                $this->setTimeout($obj->getElement($objField)->getTimeout());
            } elseif (get_class($obj) == EntityDataObject::class) {
                $replacement = $this->resolveEntityDataObjectReference($obj, $match);

                if (is_array($replacement)) {
                    $replacement = '["' . implode('","', array_map('addSlashes', $replacement)) . '"]';
                }
            }

            if ($replacement === null) {
                if (get_class($objectHandler) != DataObjectHandler::class) {
                    return $this->findAndReplaceReferences(DataObjectHandler::getInstance(), $outputString);
                } else {
                    throw new TestReferenceException(
                        "Could not resolve entity reference \"{$inputString}\" "
                        . "in Action with stepKey \"{$this->getStepKey()}\"",
                        ["input" => $inputString, "stepKey" => $this->getStepKey()]
                    );
                }
            }

            $replacement = $this->resolveParameterization($parameterized, $replacement, $match, $obj);

            $outputString = str_replace($match, $replacement, $outputString);
        }
        return $outputString;
    }

    private function validateMutuallyExclusiveAttributes(array $attributes)
    {
        $matches = array_intersect($attributes, array_keys($this->getCustomActionAttributes()));
        if (count($matches) > 1) {
            throw new TestReferenceException(
                "Actions of type '{$this->getType()}' must only contain one attribute of types '"
                . implode("', '", $attributes) . "'",
                ["type" => $this->getType(), "attributes" => $attributes]
            );
        } elseif (count($matches) == 0) {
            throw new TestReferenceException(
                "Actions of type '{$this->getType()}' must contain at least one attribute of types '"
                . implode("', '", $attributes) . "'",
                ["type" => $this->getType(), "attributes" => $attributes]
            );
        }
    }

    private function validateUrlAreaAgainstActionType($obj)
    {
        if ($obj->getArea() == 'external' &&
            in_array($this->getType(), self::EXTERNAL_URL_AREA_INVALID_ACTIONS)) {
            throw new TestReferenceException(
                "Page of type 'external' is not compatible with action type '{$this->getType()}'",
                ["type" => $this->getType()]
            );
        }
    }

    private function validateTimezoneAttribute()
    {
        $attributes = $this->getCustomActionAttributes();
        if (isset($attributes[self::ACTION_ATTRIBUTE_TIMEZONE])) {
            $timezone = $attributes[self::ACTION_ATTRIBUTE_TIMEZONE];
            try {
                new \DateTimeZone($timezone);
            } catch (\Exception $e) {
                throw new TestReferenceException(
                    "Timezone '{$timezone}' is not a valid timezone",
                    ["stepKey" => $this->getStepKey(), self::ACTION_ATTRIBUTE_TIMEZONE => $timezone]
                );
            }
        }
    }

    private function resolveEntityDataObjectReference($obj, $match)
    {
        list(,$objField) = $this->stripAndSplitReference($match);

        if (strpos($objField, '[') == true) {
            // Access <array>...</array>
            $parts = explode('[', $objField);
            $name = $parts[0];
            $index = str_replace(']', '', $parts[1]);
            return $obj->getDataByName($name, EntityDataObject::CEST_UNIQUE_NOTATION)[$index];
        } else {
            // Access <data></data>
            return $obj->getDataByName($objField, EntityDataObject::CEST_UNIQUE_NOTATION);
        }
    }

    private function resolveParameterization($isParameterized, $replacement, $match, $object)
    {
        if ($isParameterized) {
            $parameterList = $this->stripAndReturnParameters($match) ?: [];
            $resolvedReplacement = $this->matchParameterReferences($replacement, $parameterList);
        } else {
            $resolvedReplacement = $replacement;
        }
        if (get_class($object) == PageObject::class && $object->getArea() == PageObject::ADMIN_AREA) {
            $resolvedReplacement = "/{{_ENV.MAGENTO_BACKEND_NAME}}/" . $resolvedReplacement;
        }
        return $resolvedReplacement;
    }

    private function matchParameterReferences($reference, $parameters)
    {
        preg_match_all('/{{[\w.]+}}/', $reference, $varMatches);
        $varMatches[0] = array_unique($varMatches[0]);
        $this->checkParameterCount($varMatches[0], $parameters, $reference);

        //Attempt to Resolve {{data}} references to actual output. Trim parameter for whitespace before processing it.
        //If regex matched it means that it's either a 'StringLiteral' or $key.data$/$$key.data$$ reference.
        //Elseif regex match for {$data}
        //Else assume it's a normal {{data.key}} reference and recurse through findAndReplace
        $resolvedParameters = [];
        foreach ($parameters as $parameter) {
            $parameter = trim($parameter);
            preg_match_all("/[$'][\w\D]+[$']/", $parameter, $stringOrPersistedMatch);
            preg_match_all('/{\$[a-z][a-zA-Z\d]+}/', $parameter, $variableMatch);
            if (!empty($stringOrPersistedMatch[0])) {
                $resolvedParameters[] = ltrim(rtrim($parameter, "'"), "'");
            } elseif (!empty($variableMatch[0])) {
                $resolvedParameters[] = $parameter;
            } else {
                $resolvedParameters[] = $this->findAndReplaceReferences(
                    DataObjectHandler::getInstance(),
                    '{{' . $parameter . '}}'
                );
            }
        }

        $resolveIndex = 0;
        foreach ($varMatches[0] as $var) {
            $reference = str_replace($var, $resolvedParameters[$resolveIndex++], $reference);
        }
        return $reference;
    }

    private function checkParameterCount($matches, $parameters, $reference)
    {
        if (count($matches) > count($parameters)) {
            if (is_array($parameters)) {
                $parametersGiven = implode(",", $parameters);
            } elseif ($parameters == null) {
                $parametersGiven = "NONE";
            } else {
                $parametersGiven = $parameters;
            }
            throw new TestReferenceException(
                "Parameter Resolution Failed: Not enough parameters given for reference " .
                $reference . ". Parameters Given: " . $parametersGiven,
                ["reference" => $reference, "parametersGiven" => $parametersGiven]
            );
        } elseif (count($matches) < count($parameters)) {
            throw new TestReferenceException(
                "Parameter Resolution Failed: Too many parameters given for reference " .
                $reference . ". Parameters Given: " . implode(", ", $parameters),
                ["reference" => $reference, "parametersGiven" => $parameters]
            );
        } elseif (count($matches) == 0) {
            throw new TestReferenceException(
                "Parameter Resolution Failed: No parameter matches found in parameterized element with selector " .
                $reference,
                ["reference" => $reference]
            );
        }
    }
}