AbstractMetricCheck.php

Go to the documentation of this file.

<?php
namespace Magento\FunctionalTestingFramework\Extension\ReadinessMetrics;

use Codeception\Exception\ModuleRequireException;
use Codeception\Module\WebDriver;
use Codeception\Step;
use Facebook\WebDriver\Exception\UnexpectedAlertOpenException;
use Magento\FunctionalTestingFramework\Extension\PageReadinessExtension;
use Magento\FunctionalTestingFramework\Util\Logger\LoggingUtil;
use Magento\FunctionalTestingFramework\Config\MftfApplicationConfig;
use Monolog\Logger;

abstract class AbstractMetricCheck
{
    protected $extension;

    protected $currentValue;

    protected $storedValue;

    protected $failCount;

    protected $resetFailureThreshold;

    protected $logger;

    protected $verbose;

    public function __construct($extension, $resetFailureThreshold)
    {
        $this->extension = $extension;
        $this->logger = LoggingUtil::getInstance()->getLogger(get_class($this));
        $this->verbose = MftfApplicationConfig::getConfig()->verboseEnabled();

        // If the clearFailureOnPage() method is overridden, use the configured failure threshold
        // If not, the default clearFailureOnPage() method does nothing so don't worry about resetting failures
        $reflector = new \ReflectionMethod($this, 'clearFailureOnPage');
        if ($reflector->getDeclaringClass()->getName() === get_class($this)) {
            $this->resetFailureThreshold = $resetFailureThreshold;
        } else {
            $this->resetFailureThreshold = -1;
        }

        $this->resetTracker();
    }

    abstract protected function doesMetricPass($value);

    abstract protected function fetchValueFromPage();

    protected function clearFailureOnPage()
    {
        return;
    }

    public function getName()
    {
        $clazz = get_class($this);
        $namespaceBreak = strrpos($clazz, '\\');
        if ($namespaceBreak !== false) {
            $clazz = substr($clazz, $namespaceBreak + 1);
        }
        return $clazz;
    }

    public function runCheck()
    {
        if ($this->doesMetricPass($this->getCurrentValue(true))) {
            $this->setTracker($this->getCurrentValue(), 0);
            return true;
        }

        return false;
    }

    public function finalizeForStep($step)
    {
        try {
            $currentValue = $this->getCurrentValue();
        } catch (UnexpectedAlertOpenException $exception) {
            $this->debugLog(
                'An alert is open, bypassing javascript-based metric check',
                ['step' => $step->__toString()]
            );
            return;
        }

        if ($this->doesMetricPass($currentValue)) {
            $this->setTracker($currentValue, 0);
        } else {
            // If failure happened on the same value as before, increment the fail count, otherwise set at 1
            if (!isset($this->storedValue) || $currentValue !== $this->getStoredValue()) {
                $failCount = 1;
            } else {
                $failCount = $this->getFailureCount() + 1;
            }
            $this->setTracker($currentValue, $failCount);

            $this->errorLog('Failed readiness check', ['step' => $step->__toString()]);

            if ($this->resetFailureThreshold >= 0 && $failCount >= $this->resetFailureThreshold) {
                $this->debugLog(
                    'Too many failures, assuming metric is stuck and resetting state',
                    ['step' => $step->__toString()]
                );
                $this->resetMetric();
            }
        }
    }

    protected function getDriver()
    {
        return $this->extension->getDriver();
    }

    protected function executeJs($script, $arguments = [])
    {
        return $this->extension->getDriver()->executeJS($script, $arguments);
    }

    private function getCurrentValue($refresh = false)
    {
        if ($refresh) {
            unset($this->currentValue);
        }
        if (!isset($this->currentValue)) {
            $this->currentValue = $this->fetchValueFromPage();
        }
        return $this->currentValue;
    }

    public function getStoredValue()
    {
        return $this->storedValue ?? null;
    }

    public function getFailureCount()
    {
        return $this->failCount;
    }

    private function resetMetric()
    {
        $this->clearFailureOnPage();
        $this->resetTracker();
    }

    public function setTracker($value, $failCount)
    {
        unset($this->currentValue);
        $this->storedValue = $value;
        $this->failCount = $failCount;
    }

    public function resetTracker()
    {
        unset($this->currentValue);
        unset($this->storedValue);
        $this->failCount = 0;
    }

    protected function errorLog($message, $context = [])
    {
        $context = array_merge($this->getLogContext(), $context);
        //TODO REMOVE THIS LINE, UNCOMMENT LOGGER
        //$this->logger->error($message, $context);
    }

    protected function infoLog($message, $context = [])
    {
        $context = array_merge($this->getLogContext(), $context);
        //TODO REMOVE THIS LINE, UNCOMMENT LOGGER
        //$this->logger->info($message, $context);
    }

    protected function debugLog($message, $context = [])
    {
        if ($this->verbose) {
            $context = array_merge($this->getLogContext(), $context);
            //TODO REMOVE THIS LINE, UNCOMMENT LOGGER
            //$this->logger->debug($message, $context);
        }
    }

    private function getLogContext()
    {
        return [
            'test' => $this->extension->getTestName(),
            'uri' => $this->extension->getUri(),
            $this->getName() => $this->getStoredValue(),
            $this->getName() . '.failCount' => $this->getFailureCount()
        ];
    }
}