AbstractTestCase - Code Metrics - Inspection of "Updated the endTimer() to include an assertion for..." - magium/Magium - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b459f9...8174b2 )

by Kevin

created 2017-11-22 21:32 UTC

AbstractTestCase D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	642
Duplicated Lines	2.96 %

Coupling/Cohesion

Components	2
Dependencies	10

Importance

Changes

Metric	Value
wmc	94
lcom	2
cbo	10
dl	19
loc	642
rs	4.7005
c	0
b	0
f	0

58 Methods

Rating	Name	Duplication	Size	Complexity
A	startTimer()	0	4	1
B	endTimer()	0	25	2
A	setUp()	0	19	2
A	getDi()	0	4	1
A	setDi()	0	4	1
A	getWebdriver()	0	7	2
A	setWebdriver()	0	4	1
A	getInitializer()	0	4	1
A	__construct()	0	6	1
A	setUseErrorHandlerFromAnnotation()	0	10	1
A	getMasterListener()	0	11	3
B	tearDown()	0	19	5
A	filterWebDriverAction()	0	13	4
A	assertElementClickable()	0	4	1
A	assertElementNotClickable()	0	5	1
A	addBaseNamespace()	0	6	2
C	resolveClass()	0	31	7
A	setTypePreference()	0	8	1
A	normalizeClassRequest()	0	4	1
A	addPostTestCallback()	0	7	2
A	getTheme()	0	8	2
A	getAction()	0	6	1
A	getIdentity()	0	6	1
A	getNavigator()	0	6	1
A	getAssertion()	0	6	1
A	getExtractor()	0	6	1
A	sleep()	0	14	4
A	commandOpen()	0	4	1
A	getLogger()	0	4	1
A	get()	0	9	3
A	isPHPUnit5()	0	4	1
A	assertElementExists()	0	4	1
A	assertTitleEquals()	0	5	1
A	assertTitleContains()	0	5	1
A	assertNotTitleEquals()	0	5	1
A	assertNotTitleContains()	0	5	1
A	assertURLEquals()	0	5	1
A	assertURLContains()	0	5	1
A	assertURLNotEquals()	0	5	1
A	assertURLNotContains()	0	5	1
A	elementAssertion()	0	7	1
A	assertElementDisplayed()	0	4	1
A	assertElementNotDisplayed()	0	4	1
A	assertElementNotExists()	0	4	1
A	getAssertionLogger()	0	4	1
B	switchThemeConfiguration()	0	23	4
A	assertWebDriverElement()	0	4	1
A	assertElementHasText()	9	9	2
A	assertPageHasText()	10	10	2
A	assertPageNotHasText()	0	10	2
A	byXpath()	0	4	1
A	byId()	0	4	1
A	byCssSelector()	0	4	1
B	getElementByTextXpath()	0	19	5
A	byText()	0	5	1
A	byContainsText()	0	5	1
A	getTranslator()	0	4	1
A	addTranslationCsvFile()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractTestCase often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractTestCase, and based on these observations, apply Extract Interface, too.

<?php

namespace Magium;

use Facebook\WebDriver\Exception\NoSuchElementException;
use Facebook\WebDriver\Exception\WebDriverException;
use Facebook\WebDriver\WebDriverElement;
use Magium\Assertions\Element\Clickable;
use Magium\Assertions\Element\Displayed;
use Magium\Assertions\Element\Exists;
use Magium\Assertions\Element\NotClickable;
use Magium\Assertions\Element\NotDisplayed;
use Magium\Assertions\Element\NotExists;
use Magium\Assertions\LoggingAssertionExecutor;
use Magium\Commands\Open;
use Magium\TestCase\Initializer;
use Magium\TestCase\InitializerContainer;
use Magium\Themes\BaseThemeInterface;
use Magium\Util\Log\LoggerInterface;
use Magium\Util\Phpunit\MasterListener;
use Magium\Util\Phpunit\MasterListenerInterface;
use Magium\WebDriver\WebDriver;
use PHPUnit\Framework\TestCase;
use Zend\Di\Di;

abstract class AbstractTestCase extends TestCase
{

    protected static $baseNamespaces = [];

    protected $baseThemeClass = 'Magium\Themes\ThemeConfigurationInterface';

    protected $postCallbacks = [];

    /**
     * @var MasterListener
     */

    protected static $masterListener;

    /**
     * @var \Magium\WebDriver\WebDriver
     */
    protected $webdriver;

    /**
     * @var Di
     */

    protected $di;

    protected $textElementNodeSearch = [
        'button', 'span', 'a', 'li', 'label', 'option', 'h1', 'h2', 'h3', 'td'
    ];

    protected $initializer;

    const BY_XPATH = 'byXpath';
    const BY_ID    = 'byId';
    const BY_CSS_SELECTOR = 'byCssSelector';
    const BY_TEXT = 'byText';

    private $sectionTimerStart;

    public function startTimer()
    {
        $this->sectionTimerStart = microtime(true);
    }

    public function endTimer($name, $minimumElapsedTime = 0)
    {
        $endTime = microtime(true);
        if (!$this->sectionTimerStart) {
            throw new \Exception('sendTimer(name) requires startTimer() to be called previously');
        }

        $elapsedMs = (int)(($endTime - $this->sectionTimerStart) * 1000);
        $elapsedExact = $endTime - $this->sectionTimerStart;

        $pass = $elapsedExact > $minimumElapsedTime;

        $message = sprintf('%s - elapsed %s', $name, $elapsedMs);
        $this->getLogger()->info($message, [
            'type' => 'timer',
            'name' => $name,
            'elapsed_ms' => $elapsedMs,
            'elapsed' => $elapsedExact,
            'start_time' => $this->sectionTimerStart,
            'end_time' => $endTime,
            'pass' => $pass
        ]);
        $this->sectionTimerStart = false;
        self::assertGreaterThan($minimumElapsedTime, $elapsedExact);
    }

    protected static $registrationCallbacks;

    protected function setUp()
    {
        /**
         * Putting this in the setup and not in the property means that an extending class can inject itself easily
         * before the Magium namespace, thus, taking preference over the base namespace
         */

        self::addBaseNamespace('Magium');

        /**
         * This weird little bit of code (the InitializerContainer) is done like this so we can provide a type
         * preference for the Initializer.  This is because Magium is a DI-based setup rigged inside a non-DI-based
         * setup
         */
        if (!$this->initializer instanceof InitializerContainer) {
            $this->initializer = Initializer::getInitializationDependencyInjectionContainer()->get(InitializerContainer::class);
        }
        $this->initializer->initialize($this);
    }

    /**
     * @return Di
     */
    public function getDi()
    {
        return $this->di;
    }

    /**
     * @param Di $di
     */
    public function setDi($di)
    {
        $this->di = $di;
    }

    /**
     * @return WebDriver
     */
    public function getWebdriver()
    {
        if (!$this->webdriver instanceof WebDriver) {
            $this->webdriver = $this->get(WebDriver::class);
        }
        return $this->webdriver;
    }

    /**
     * @param WebDriver $webdriver
     */
    public function setWebdriver(WebDriver $webdriver)
    {
        $this->webdriver = $webdriver;
    }

    public function getInitializer()
    {
        return $this->initializer;
    }


    public function __construct($name = null, array $data = [], $dataName = null, Initializer $initializer = null)

    {
        // Init at the earliest possible convenience.
        self::getMasterListener();
        parent::__construct($name, $data, $dataName);
    }

    public function setUseErrorHandlerFromAnnotation() {
        /*
         * This odd little function is here because the first place where you can reliably add a listener without
         * having to make a phpunit.xml or program argument change AND the result object is available AND there is
         * no incompatibility with PHPUnit 5.
         */
        $result = $this->getTestResultObject();
        self::getMasterListener()->bindToResult($result);
        return parent::setUseErrorHandlerFromAnnotation();
    }

    /**
     * @return MasterListener
     */

    public static function getMasterListener()
    {
        if (!self::$masterListener instanceof MasterListenerInterface) {
            if (interface_exists('PHPUnit_Framework_Test')) {
                self::$masterListener = new \Magium\Util\Phpunit5\MasterListener();

            } else {
                self::$masterListener = new MasterListener();
            }
        }
        return self::$masterListener;

    }

    protected function tearDown()
    {
        foreach ($this->postCallbacks as $callback) {
            if (is_callable($callback)) {
                call_user_func($callback);
            }
        }
        parent::tearDown();
        if ($this->webdriver instanceof WebDriver) {
            try {
                $this->webdriver->close();
            } catch (\Exception $e) {
                // All closed
            }

            $this->webdriver->quit();
            $this->webdriver = null;
        }
    }


    public function filterWebDriverAction($by)
    {
        switch ($by) {
            case WebDriver::BY_XPATH:
                return 'xpath';
            case WebDriver::BY_CSS_SELECTOR:
                return 'css_selector';
            case WebDriver::BY_ID:
                return 'id';
            default:
                return $by;
        }
    }

    public function assertElementClickable($selector, $by = WebDriver::BY_ID)
    {
        $this->elementAssertion($selector, $by, Clickable::ASSERTION);
    }


    public function assertElementNotClickable($selector, $by = WebDriver::BY_ID)
    {
        $this->elementAssertion($selector, $by, NotClickable::ASSERTION);

    }

    public static function addBaseNamespace($namespace)
    {
        if (!in_array($namespace, self::$baseNamespaces)) {
            self::$baseNamespaces[] = trim($namespace, '\\');
        }
    }

    public static function resolveClass( $class, $prefix = null)
    {
        $origClass = $class;
        if ($prefix !== null) {
            $class = "{$prefix}\\{$class}";
        }
        foreach (self::$baseNamespaces as $namespace) {
            if (strpos($class, $namespace) === 0) {
                // We have a fully qualified class name
                return $class;
            }
        }

        foreach (self::$baseNamespaces as $namespace) {
            $fqClass = $namespace . '\\' . $class;
            try {
                if (class_exists($fqClass)) {
                    return $fqClass;
                }
            } catch (\Exception $e) {
                /*
                 * Nothing to see here
                 * http://www.reactiongifs.us/wp-content/uploads/2015/04/nothing_to_see_here_naked_gun.gif
                 *
                 * This is necessary because, in Magento, when developer mode is turned on, Magento will throw an
                 * exception if the autoloader can't find a file.
                 */
            }
        }
        return $origClass;
    }

    public function setTypePreference($type, $preference)
    {
        $type = self::resolveClass($type);
        $preference = self::resolveClass($preference);
        $this->di->instanceManager()->unsetTypePreferences($type);
        $this->di->instanceManager()->setTypePreference($type, [$preference]);

    }

    protected function normalizeClassRequest($class)
    {
        return str_replace('/', '\\', $class);
    }

    public function addPostTestCallback($callback)
    {
        if (!is_callable($callback)) {
            throw new InvalidConfigurationException('Callback is not callable');
        }
        $this->postCallbacks[] = $callback;
    }

    /**

     * @param string $theme
     * @return \Magium\Themes\ThemeConfigurationInterface
     */

    public function getTheme($theme = null)
    {
        if ($theme === null) {
            return $this->get($this->baseThemeClass);
        }
        $theme = self::resolveClass($theme, 'Themes');
        return $this->get($theme);
    }

    /**
     *
     * @param string $action
     * @return mixed
     */

    public function getAction($action)
    {
        $action = self::resolveClass($action, 'Actions');

        return $this->get($action);
    }


    /**
     * @param string $name
     * @return \Magium\Identities\NameInterface
     */

    public function getIdentity($name = 'Customer')
    {
        $name = self::resolveClass($name, 'Identities');

        return $this->get($name);
    }

    /**
     *
     * @param string $navigator
     * @return \Magium\Navigators\NavigatorInterface
     */

    public function getNavigator($navigator = 'BaseMenu')
    {
        $navigator = self::resolveClass($navigator, 'Navigators');

        return $this->get($navigator);
    }

    public function getAssertion($assertion)
    {
        $assertion = self::resolveClass($assertion, 'Assertions');

        return $this->get($assertion);
    }

    /**
     *
     * @param string $extractor
     * @return \Magium\Extractors\AbstractExtractor
     */

    public function getExtractor($extractor)
    {
        $extractor = self::resolveClass($extractor, 'Extractors');

        return $this->get($extractor);
    }

    /**
     * Sleep the specified amount of time.
     *
     * Options: 1s (1 second), 1ms (1 millisecond), 1us (1 microsecond), 1ns (1 nanosecond)
     *
     * @param $time
     */

    public function sleep($time)
    {
        $length = (int)$time;

        if (strpos($time, 'ms') !== false) {
            usleep($length * 1000);
        } else if (strpos($time, 'us') !== false) {
            usleep($length);
        } else if (strpos($time, 'ns') !== false) {
            time_nanosleep(0, $length);
        } else {
            sleep($length);
        }
    }


    public function commandOpen($url)
    {
        $this->get(Open::class)->open($url);
    }


    /**
     * @return LoggerInterface
     */

    public function getLogger()
    {
        return $this->get(LoggerInterface::class);
    }

    public function get($class)
    {
        $class = $this->normalizeClassRequest($class);
        $preferredClass = $this->di->instanceManager()->getTypePreferences($class);
        if (is_array($preferredClass) && count($preferredClass) > 0) {
            $class = array_shift($preferredClass);
        }
        return $this->di->get($class);
    }

    public static function isPHPUnit5()
    {
        return class_exists('PHPUnit_Framework_TestSuite');
    }

    public function assertElementExists($selector, $by = 'byId')
    {
        $this->elementAssertion($selector, $by, Exists::ASSERTION);
    }

    public function assertTitleEquals($title)
    {
        $webTitle = $this->webdriver->getTitle();
        self::assertEquals($title, $webTitle);
    }


    public function assertTitleContains($title)
    {
        $webTitle = $this->webdriver->getTitle();
        self::assertContains($title, $webTitle);
    }


    public function assertNotTitleEquals($title)
    {
        $webTitle = $this->webdriver->getTitle();
        self::assertNotEquals($title, $webTitle);
    }


    public function assertNotTitleContains($title)
    {
        $webTitle = $this->webdriver->getTitle();
        self::assertNotContains($title, $webTitle);
    }

    public function assertURLEquals($url)
    {
        $webUrl = $this->webdriver->getCurrentURL();
        self::assertEquals($url, $webUrl);
    }

    public function assertURLContains($url)
    {
        $webUrl = $this->webdriver->getCurrentURL();
        self::assertContains($url, $webUrl);
    }


    public function assertURLNotEquals($url)
    {
        $webUrl = $this->webdriver->getCurrentURL();
        self::assertNotEquals($url, $webUrl);
    }

    public function assertURLNotContains($url)
    {
        $webUrl = $this->webdriver->getCurrentURL();
        self::assertNotContains($url, $webUrl);
    }

    protected function elementAssertion($selector, $by, $name)
    {
        $executor = $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
        $assertion = $this->getAssertion($name);
        $assertion->setSelector($selector)->setBy($by);
        $executor->execute($assertion);
    }

    public function assertElementDisplayed($selector, $by = 'byId')
    {
        $this->elementAssertion($selector, $by, Displayed::ASSERTION);
    }

    public function assertElementNotDisplayed($selector, $by = 'byId')
    {
        $this->elementAssertion($selector, $by, NotDisplayed::ASSERTION);
    }

    public function assertElementNotExists($selector, $by = 'byId')
    {
        $this->elementAssertion($selector, $by, NotExists::ASSERTION);
    }

    /**
     * @return LoggingAssertionExecutor
     */

    public function getAssertionLogger()
    {
        return $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
    }

    public function switchThemeConfiguration($fullyQualifiedClassName)
    {

        $reflection = new \ReflectionClass($fullyQualifiedClassName);

        if ($reflection->implementsInterface('Magium\Themes\ThemeConfigurationInterface')) {
            $this->baseThemeClass = $fullyQualifiedClassName;
            $this->di->instanceManager()->unsetTypePreferences('Magium\Themes\ThemeConfigurationInterface');
            $this->di->instanceManager()->setTypePreference('Magium\Themes\ThemeConfigurationInterface', [$fullyQualifiedClassName]);

            if ($reflection->implementsInterface('Magium\Themes\BaseThemeInterface')) {
                $this->di->instanceManager()->unsetTypePreferences('Magium\Themes\BaseThemeInterface');
                $this->di->instanceManager()->setTypePreference('Magium\Themes\BaseThemeInterface', [$fullyQualifiedClassName]);
            }
            $theme = $this->getTheme();
            if ($theme instanceof BaseThemeInterface) {
                $theme->configure($this);
            }
        } else {
            throw new InvalidConfigurationException('The theme configuration implement Magium\Themes\ThemeConfigurationInterface');
        }
        $this->getLogger()->addCharacteristic(LoggerInterface::CHARACTERISTIC_THEME, $fullyQualifiedClassName);
    }

    public static function assertWebDriverElement($element)
    {
        self::assertInstanceOf('Facebook\WebDriver\WebDriverElement', $element);
    }

    public function assertElementHasText($node, $text)

    {
        try {
            $element = $this->byXpath(sprintf('//%s[contains(., "%s")]', $node, addslashes($text)));
            self::assertWebDriverElement($element);
        } catch (\Exception $e) {
            $this->fail('The body did not contain the text: ' . $text);
        }
    }

    public function assertPageHasText($text)

    {
        try {
            $element = $this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
            // If the element is not found then an exception will be thrown
            self::assertWebDriverElement($element);
        } catch (\Exception $e) {
            $this->fail('The body did not contain the text: ' . $text);
        }
    }

    public function assertPageNotHasText($text)
    {
        try {
            $this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
            $this->fail('The page contains the words: ' . $text);
        } catch (NoSuchElementException $e) {
            // Exception thrown is a success
            self::assertInstanceOf(NoSuchElementException::class, $e);
        }
    }

    /**
     * @param $xpath
     * @return \Facebook\WebDriver\Remote\RemoteWebElement
     */

    public function byXpath($xpath)
    {
        return $this->webdriver->byXpath($xpath);
    }

    /**
     * @param $id
     * @return \Facebook\WebDriver\Remote\RemoteWebElement
     */

    public function byId($id)
    {
        return $this->webdriver->byId($id);
    }

    /**
     * @param $selector
     * @return \Facebook\WebDriver\Remote\RemoteWebElement
     */

    public function byCssSelector($selector)
    {
        return $this->webdriver->byCssSelector($selector);
    }

    protected function getElementByTextXpath($xpathTemplate, $text, $specificNodeType = null, $parentElementSelector = null)
    {

        if ($parentElementSelector !== null) {
            $xpathTemplate = $parentElementSelector . $xpathTemplate;
        }
        if ($specificNodeType !== null) {
            return $this->byXpath(sprintf($xpathTemplate, $specificNodeType, $this->getTranslator()->translatePlaceholders($text)));
        }

        foreach ($this->textElementNodeSearch as $nodeName) {
            $xpath = sprintf($xpathTemplate, $nodeName, $this->getTranslator()->translatePlaceholders($text));
            if ($this->webdriver->elementExists($xpath, WebDriver::BY_XPATH)) {
                return $this->webdriver->byXpath($xpath);
            }
        }
        // This is here for consistency with the other by* methods
        WebDriverException::throwException(7, 'Could not find element with text: ' . $this->getTranslator()->translatePlaceholders($text), []);
    }

    /**
     * @param string $text
     * @param string $specificNodeType
     * @param string $parentElementSelector
     * @return \Facebook\WebDriver\Remote\RemoteWebElement
     */
    public function byText($text, $specificNodeType = null, $parentElementSelector = null)
    {
        $xpathTemplate = '//%s[concat(" ",normalize-space(.)," ") = " %s "]';
        return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
    }


    /**
     * @param string $text
     * @param string $specificNodeType
     * @param string $parentElementSelector
     * @return \Facebook\WebDriver\Remote\RemoteWebElement
     */
    public function byContainsText($text, $specificNodeType = null, $parentElementSelector = null)
    {
        $xpathTemplate = '//%s[contains(., "%s")]';
        return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
    }

    /**
     * @return \Magium\Util\Translator\Translator
     */

    public function getTranslator()
    {
        return $this->get('Magium\Util\Translator\Translator');
    }

    public function addTranslationCsvFile($file, $locale)
    {
        $this->getTranslator()->addTranslationCsvFile($file, $locale);
    }
}


1		<?php
2
3		namespace Magium;
4
5		use Facebook\WebDriver\Exception\NoSuchElementException;
6		use Facebook\WebDriver\Exception\WebDriverException;
7		use Facebook\WebDriver\WebDriverElement;
8		use Magium\Assertions\Element\Clickable;
9		use Magium\Assertions\Element\Displayed;
10		use Magium\Assertions\Element\Exists;
11		use Magium\Assertions\Element\NotClickable;
12		use Magium\Assertions\Element\NotDisplayed;
13		use Magium\Assertions\Element\NotExists;
14		use Magium\Assertions\LoggingAssertionExecutor;
15		use Magium\Commands\Open;
16		use Magium\TestCase\Initializer;
17		use Magium\TestCase\InitializerContainer;
18		use Magium\Themes\BaseThemeInterface;
19		use Magium\Util\Log\LoggerInterface;
20		use Magium\Util\Phpunit\MasterListener;
21		use Magium\Util\Phpunit\MasterListenerInterface;
22		use Magium\WebDriver\WebDriver;
23		use PHPUnit\Framework\TestCase;
24		use Zend\Di\Di;
25
26		abstract class AbstractTestCase extends TestCase
27		{
28
29		protected static $baseNamespaces = [];
30
31		protected $baseThemeClass = 'Magium\Themes\ThemeConfigurationInterface';
32
33		protected $postCallbacks = [];
34
35		/**
36		* @var MasterListener
37		*/
38
39		protected static $masterListener;
40
41		/**
42		* @var \Magium\WebDriver\WebDriver
43		*/
44		protected $webdriver;
45
46		/**
47		* @var Di
48		*/
49
50		protected $di;
51
52		protected $textElementNodeSearch = [
53		'button', 'span', 'a', 'li', 'label', 'option', 'h1', 'h2', 'h3', 'td'
54		];
55
56		protected $initializer;
57
58		const BY_XPATH = 'byXpath';
59		const BY_ID = 'byId';
60		const BY_CSS_SELECTOR = 'byCssSelector';
61		const BY_TEXT = 'byText';
62
63		private $sectionTimerStart;
64
65		public function startTimer()
66		{
67		$this->sectionTimerStart = microtime(true);
68		}
69
70		public function endTimer($name, $minimumElapsedTime = 0)
71		{
72		$endTime = microtime(true);
73		if (!$this->sectionTimerStart) {
74		throw new \Exception('sendTimer(name) requires startTimer() to be called previously');
75		}
76
77		$elapsedMs = (int)(($endTime - $this->sectionTimerStart) * 1000);
78		$elapsedExact = $endTime - $this->sectionTimerStart;
79
80		$pass = $elapsedExact > $minimumElapsedTime;
81
82		$message = sprintf('%s - elapsed %s', $name, $elapsedMs);
83		$this->getLogger()->info($message, [
84		'type' => 'timer',
85		'name' => $name,
86		'elapsed_ms' => $elapsedMs,
87		'elapsed' => $elapsedExact,
88		'start_time' => $this->sectionTimerStart,
89		'end_time' => $endTime,
90		'pass' => $pass
91		]);
92		$this->sectionTimerStart = false;
93		self::assertGreaterThan($minimumElapsedTime, $elapsedExact);
94		}
95
96		protected static $registrationCallbacks;
97
98		protected function setUp()
99		{
100		/**
101		* Putting this in the setup and not in the property means that an extending class can inject itself easily
102		* before the Magium namespace, thus, taking preference over the base namespace
103		*/
104
105		self::addBaseNamespace('Magium');
106
107		/**
108		* This weird little bit of code (the InitializerContainer) is done like this so we can provide a type
109		* preference for the Initializer. This is because Magium is a DI-based setup rigged inside a non-DI-based
110		* setup
111		*/
112		if (!$this->initializer instanceof InitializerContainer) {
113		$this->initializer = Initializer::getInitializationDependencyInjectionContainer()->get(InitializerContainer::class);
114		}
115		$this->initializer->initialize($this);
116		}
117
118		/**
119		* @return Di
120		*/
121		public function getDi()
122		{
123		return $this->di;
124		}
125
126		/**
127		* @param Di $di
128		*/
129		public function setDi($di)
130		{
131		$this->di = $di;
132		}
133
134		/**
135		* @return WebDriver
136		*/
137		public function getWebdriver()
138		{
139		if (!$this->webdriver instanceof WebDriver) {
140		$this->webdriver = $this->get(WebDriver::class);
141		}
142		return $this->webdriver;
143		}
144
145		/**
146		* @param WebDriver $webdriver
147		*/
148		public function setWebdriver(WebDriver $webdriver)
149		{
150		$this->webdriver = $webdriver;
151		}
152
153		public function getInitializer()
154		{
155		return $this->initializer;
156		}
157
158
159		public function __construct($name = null, array $data = [], $dataName = null, Initializer $initializer = null)
		0 ignored issues – show Unused Code introduced 2017-08-09 22:16 UTC by Report Bug Copy Issue Report The parameter `$initializer` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
160		{
161		// Init at the earliest possible convenience.
162		self::getMasterListener();
163		parent::__construct($name, $data, $dataName);
164		}
165
166		public function setUseErrorHandlerFromAnnotation() {
167		/*
168		* This odd little function is here because the first place where you can reliably add a listener without
169		* having to make a phpunit.xml or program argument change AND the result object is available AND there is
170		* no incompatibility with PHPUnit 5.
171		*/
172		$result = $this->getTestResultObject();
173		self::getMasterListener()->bindToResult($result);
174		return parent::setUseErrorHandlerFromAnnotation();
175		}
176
177		/**
178		* @return MasterListener
179		*/
180
181		public static function getMasterListener()
182		{
183		if (!self::$masterListener instanceof MasterListenerInterface) {
184		if (interface_exists('PHPUnit_Framework_Test')) {
185		self::$masterListener = new \Magium\Util\Phpunit5\MasterListener();
		0 ignored issues – show Documentation Bug introduced 2017-11-21 18:14 UTC by Report Bug Copy Issue Report It seems like `new \Magium\Util\Phpunit5\MasterListener()` of type `object<Magium\Util\Phpunit5\MasterListener>` is incompatible with the declared type `object<Magium\Util\Phpunit\MasterListener>` of property `$masterListener`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
186		} else {
187		self::$masterListener = new MasterListener();
188		}
189		}
190		return self::$masterListener;
		0 ignored issues – show Bug Compatibility introduced 2017-11-21 18:14 UTC by Report Bug Copy Issue Report The expression `self::$masterListener;` of type `Magium\Util\Phpunit5\Mas...\Phpunit\MasterListener` adds the type `Magium\Util\Phpunit5\MasterListener` to the return on line 190 which is incompatible with the return type documented by `Magium\AbstractTestCase::getMasterListener` of type `Magium\Util\Phpunit\MasterListener`. Loading history...
191		}
192
193		protected function tearDown()
194		{
195		foreach ($this->postCallbacks as $callback) {
196		if (is_callable($callback)) {
197		call_user_func($callback);
198		}
199		}
200		parent::tearDown();
201		if ($this->webdriver instanceof WebDriver) {
202		try {
203		$this->webdriver->close();
204		} catch (\Exception $e) {
205		// All closed
206		}
207
208		$this->webdriver->quit();
209		$this->webdriver = null;
210		}
211		}
212
213
214		public function filterWebDriverAction($by)
215		{
216		switch ($by) {
217		case WebDriver::BY_XPATH:
218		return 'xpath';
219		case WebDriver::BY_CSS_SELECTOR:
220		return 'css_selector';
221		case WebDriver::BY_ID:
222		return 'id';
223		default:
224		return $by;
225		}
226		}
227
228		public function assertElementClickable($selector, $by = WebDriver::BY_ID)
229		{
230		$this->elementAssertion($selector, $by, Clickable::ASSERTION);
231		}
232
233
234		public function assertElementNotClickable($selector, $by = WebDriver::BY_ID)
235		{
236		$this->elementAssertion($selector, $by, NotClickable::ASSERTION);
237
238		}
239
240		public static function addBaseNamespace($namespace)
241		{
242		if (!in_array($namespace, self::$baseNamespaces)) {
243		self::$baseNamespaces[] = trim($namespace, '\\');
244		}
245		}
246
247		public static function resolveClass( $class, $prefix = null)
248		{
249		$origClass = $class;
250		if ($prefix !== null) {
251		$class = "{$prefix}\\{$class}";
252		}
253		foreach (self::$baseNamespaces as $namespace) {
254		if (strpos($class, $namespace) === 0) {
255		// We have a fully qualified class name
256		return $class;
257		}
258		}
259
260		foreach (self::$baseNamespaces as $namespace) {
261		$fqClass = $namespace . '\\' . $class;
262		try {
263		if (class_exists($fqClass)) {
264		return $fqClass;
265		}
266		} catch (\Exception $e) {
267		/*
268		* Nothing to see here
269		* http://www.reactiongifs.us/wp-content/uploads/2015/04/nothing_to_see_here_naked_gun.gif
270		*
271		* This is necessary because, in Magento, when developer mode is turned on, Magento will throw an
272		* exception if the autoloader can't find a file.
273		*/
274		}
275		}
276		return $origClass;
277		}
278
279		public function setTypePreference($type, $preference)
280		{
281		$type = self::resolveClass($type);
282		$preference = self::resolveClass($preference);
283		$this->di->instanceManager()->unsetTypePreferences($type);
284		$this->di->instanceManager()->setTypePreference($type, [$preference]);
285
286		}
287
288		protected function normalizeClassRequest($class)
289		{
290		return str_replace('/', '\\', $class);
291		}
292
293		public function addPostTestCallback($callback)
294		{
295		if (!is_callable($callback)) {
296		throw new InvalidConfigurationException('Callback is not callable');
297		}
298		$this->postCallbacks[] = $callback;
299		}
300
301		/**
302
303		* @param string $theme
304		* @return \Magium\Themes\ThemeConfigurationInterface
305		*/
306
307		public function getTheme($theme = null)
308		{
309		if ($theme === null) {
310		return $this->get($this->baseThemeClass);
311		}
312		$theme = self::resolveClass($theme, 'Themes');
313		return $this->get($theme);
314		}
315
316		/**
317		*
318		* @param string $action
319		* @return mixed
320		*/
321
322		public function getAction($action)
323		{
324		$action = self::resolveClass($action, 'Actions');
325
326		return $this->get($action);
327		}
328
329
330		/**
331		* @param string $name
332		* @return \Magium\Identities\NameInterface
333		*/
334
335		public function getIdentity($name = 'Customer')
336		{
337		$name = self::resolveClass($name, 'Identities');
338
339		return $this->get($name);
340		}
341
342		/**
343		*
344		* @param string $navigator
345		* @return \Magium\Navigators\NavigatorInterface
346		*/
347
348		public function getNavigator($navigator = 'BaseMenu')
349		{
350		$navigator = self::resolveClass($navigator, 'Navigators');
351
352		return $this->get($navigator);
353		}
354
355		public function getAssertion($assertion)
356		{
357		$assertion = self::resolveClass($assertion, 'Assertions');
358
359		return $this->get($assertion);
360		}
361
362		/**
363		*
364		* @param string $extractor
365		* @return \Magium\Extractors\AbstractExtractor
366		*/
367
368		public function getExtractor($extractor)
369		{
370		$extractor = self::resolveClass($extractor, 'Extractors');
371
372		return $this->get($extractor);
373		}
374
375		/**
376		* Sleep the specified amount of time.
377		*
378		* Options: 1s (1 second), 1ms (1 millisecond), 1us (1 microsecond), 1ns (1 nanosecond)
379		*
380		* @param $time
381		*/
382
383		public function sleep($time)
384		{
385		$length = (int)$time;
386
387		if (strpos($time, 'ms') !== false) {
388		usleep($length * 1000);
389		} else if (strpos($time, 'us') !== false) {
390		usleep($length);
391		} else if (strpos($time, 'ns') !== false) {
392		time_nanosleep(0, $length);
393		} else {
394		sleep($length);
395		}
396		}
397
398
399		public function commandOpen($url)
400		{
401		$this->get(Open::class)->open($url);
402		}
403
404
405		/**
406		* @return LoggerInterface
407		*/
408
409		public function getLogger()
410		{
411		return $this->get(LoggerInterface::class);
412		}
413
414		public function get($class)
415		{
416		$class = $this->normalizeClassRequest($class);
417		$preferredClass = $this->di->instanceManager()->getTypePreferences($class);
418		if (is_array($preferredClass) && count($preferredClass) > 0) {
419		$class = array_shift($preferredClass);
420		}
421		return $this->di->get($class);
422		}
423
424		public static function isPHPUnit5()
425		{
426		return class_exists('PHPUnit_Framework_TestSuite');
427		}
428
429		public function assertElementExists($selector, $by = 'byId')
430		{
431		$this->elementAssertion($selector, $by, Exists::ASSERTION);
432		}
433
434		public function assertTitleEquals($title)
435		{
436		$webTitle = $this->webdriver->getTitle();
437		self::assertEquals($title, $webTitle);
438		}
439
440
441		public function assertTitleContains($title)
442		{
443		$webTitle = $this->webdriver->getTitle();
444		self::assertContains($title, $webTitle);
445		}
446
447
448		public function assertNotTitleEquals($title)
449		{
450		$webTitle = $this->webdriver->getTitle();
451		self::assertNotEquals($title, $webTitle);
452		}
453
454
455		public function assertNotTitleContains($title)
456		{
457		$webTitle = $this->webdriver->getTitle();
458		self::assertNotContains($title, $webTitle);
459		}
460
461		public function assertURLEquals($url)
462		{
463		$webUrl = $this->webdriver->getCurrentURL();
464		self::assertEquals($url, $webUrl);
465		}
466
467		public function assertURLContains($url)
468		{
469		$webUrl = $this->webdriver->getCurrentURL();
470		self::assertContains($url, $webUrl);
471		}
472
473
474		public function assertURLNotEquals($url)
475		{
476		$webUrl = $this->webdriver->getCurrentURL();
477		self::assertNotEquals($url, $webUrl);
478		}
479
480		public function assertURLNotContains($url)
481		{
482		$webUrl = $this->webdriver->getCurrentURL();
483		self::assertNotContains($url, $webUrl);
484		}
485
486		protected function elementAssertion($selector, $by, $name)
487		{
488		$executor = $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
489		$assertion = $this->getAssertion($name);
490		$assertion->setSelector($selector)->setBy($by);
491		$executor->execute($assertion);
492		}
493
494		public function assertElementDisplayed($selector, $by = 'byId')
495		{
496		$this->elementAssertion($selector, $by, Displayed::ASSERTION);
497		}
498
499		public function assertElementNotDisplayed($selector, $by = 'byId')
500		{
501		$this->elementAssertion($selector, $by, NotDisplayed::ASSERTION);
502		}
503
504		public function assertElementNotExists($selector, $by = 'byId')
505		{
506		$this->elementAssertion($selector, $by, NotExists::ASSERTION);
507		}
508
509		/**
510		* @return LoggingAssertionExecutor
511		*/
512
513		public function getAssertionLogger()
514		{
515		return $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
516		}
517
518		public function switchThemeConfiguration($fullyQualifiedClassName)
519		{
520
521		$reflection = new \ReflectionClass($fullyQualifiedClassName);
522
523		if ($reflection->implementsInterface('Magium\Themes\ThemeConfigurationInterface')) {
524		$this->baseThemeClass = $fullyQualifiedClassName;
525		$this->di->instanceManager()->unsetTypePreferences('Magium\Themes\ThemeConfigurationInterface');
526		$this->di->instanceManager()->setTypePreference('Magium\Themes\ThemeConfigurationInterface', [$fullyQualifiedClassName]);
527
528		if ($reflection->implementsInterface('Magium\Themes\BaseThemeInterface')) {
529		$this->di->instanceManager()->unsetTypePreferences('Magium\Themes\BaseThemeInterface');
530		$this->di->instanceManager()->setTypePreference('Magium\Themes\BaseThemeInterface', [$fullyQualifiedClassName]);
531		}
532		$theme = $this->getTheme();
533		if ($theme instanceof BaseThemeInterface) {
534		$theme->configure($this);
535		}
536		} else {
537		throw new InvalidConfigurationException('The theme configuration implement Magium\Themes\ThemeConfigurationInterface');
538		}
539		$this->getLogger()->addCharacteristic(LoggerInterface::CHARACTERISTIC_THEME, $fullyQualifiedClassName);
540		}
541
542		public static function assertWebDriverElement($element)
543		{
544		self::assertInstanceOf('Facebook\WebDriver\WebDriverElement', $element);
545		}
546
547	View Code Duplication	public function assertElementHasText($node, $text)
		0 ignored issues – show Duplication introduced 2017-11-21 18:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
548		{
549		try {
550		$element = $this->byXpath(sprintf('//%s[contains(., "%s")]', $node, addslashes($text)));
551		self::assertWebDriverElement($element);
552		} catch (\Exception $e) {
553		$this->fail('The body did not contain the text: ' . $text);
554		}
555		}
556
557	View Code Duplication	public function assertPageHasText($text)
		0 ignored issues – show Duplication introduced 2017-11-21 18:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
558		{
559		try {
560		$element = $this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
561		// If the element is not found then an exception will be thrown
562		self::assertWebDriverElement($element);
563		} catch (\Exception $e) {
564		$this->fail('The body did not contain the text: ' . $text);
565		}
566		}
567
568		public function assertPageNotHasText($text)
569		{
570		try {
571		$this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
572		$this->fail('The page contains the words: ' . $text);
573		} catch (NoSuchElementException $e) {
574		// Exception thrown is a success
575		self::assertInstanceOf(NoSuchElementException::class, $e);
576		}
577		}
578
579		/**
580		* @param $xpath
581		* @return \Facebook\WebDriver\Remote\RemoteWebElement
582		*/
583
584		public function byXpath($xpath)
585		{
586		return $this->webdriver->byXpath($xpath);
587		}
588
589		/**
590		* @param $id
591		* @return \Facebook\WebDriver\Remote\RemoteWebElement
592		*/
593
594		public function byId($id)
595		{
596		return $this->webdriver->byId($id);
597		}
598
599		/**
600		* @param $selector
601		* @return \Facebook\WebDriver\Remote\RemoteWebElement
602		*/
603
604		public function byCssSelector($selector)
605		{
606		return $this->webdriver->byCssSelector($selector);
607		}
608
609		protected function getElementByTextXpath($xpathTemplate, $text, $specificNodeType = null, $parentElementSelector = null)
610		{
611
612		if ($parentElementSelector !== null) {
613		$xpathTemplate = $parentElementSelector . $xpathTemplate;
614		}
615		if ($specificNodeType !== null) {
616		return $this->byXpath(sprintf($xpathTemplate, $specificNodeType, $this->getTranslator()->translatePlaceholders($text)));
617		}
618
619		foreach ($this->textElementNodeSearch as $nodeName) {
620		$xpath = sprintf($xpathTemplate, $nodeName, $this->getTranslator()->translatePlaceholders($text));
621		if ($this->webdriver->elementExists($xpath, WebDriver::BY_XPATH)) {
622		return $this->webdriver->byXpath($xpath);
623		}
624		}
625		// This is here for consistency with the other by* methods
626		WebDriverException::throwException(7, 'Could not find element with text: ' . $this->getTranslator()->translatePlaceholders($text), []);
627		}
628
629		/**
630		* @param string $text
631		* @param string $specificNodeType
632		* @param string $parentElementSelector
633		* @return \Facebook\WebDriver\Remote\RemoteWebElement
634		*/
635		public function byText($text, $specificNodeType = null, $parentElementSelector = null)
636		{
637		$xpathTemplate = '//%s[concat(" ",normalize-space(.)," ") = " %s "]';
638		return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
639		}
640
641
642		/**
643		* @param string $text
644		* @param string $specificNodeType
645		* @param string $parentElementSelector
646		* @return \Facebook\WebDriver\Remote\RemoteWebElement
647		*/
648		public function byContainsText($text, $specificNodeType = null, $parentElementSelector = null)
649		{
650		$xpathTemplate = '//%s[contains(., "%s")]';
651		return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
652		}
653
654		/**
655		* @return \Magium\Util\Translator\Translator
656		*/
657
658		public function getTranslator()
659		{
660		return $this->get('Magium\Util\Translator\Translator');
661		}
662
663		public function addTranslationCsvFile($file, $locale)
664		{
665		$this->getTranslator()->addTranslationCsvFile($file, $locale);
666		}
667		}
668

magium / Magium