Magium\AbstractTestCase

Complexity

Total Complexity

87

Size/Duplication

Total Lines	581
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes	36
Bugs	6	Features	8

55 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	10	1
A	getDi()	0	4	1
A	setDi()	0	4	1
A	getWebdriver()	0	4	1
A	setWebdriver()	0	4	1
A	getInitializer()	0	4	1
A	__construct()	0	10	2
A	setTestResultObject()	0	8	1
A	getMasterListener()	0	7	2
A	tearDown()	0	13	4
A	filterWebDriverAction()	0	13	4
A	assertElementClickable()	0	4	1
A	assertElementNotClickable()	0	5	1
A	addBaseNamespace()	0	6	2
B	resolveClass()	0	21	6
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	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	12	2
A	assertElementNotExists()	0	4	1
A	getAssertionLogger()	0	4	1
B	switchThemeConfiguration()	0	23	4
A	assertWebDriverElement()	0	4	1
A	assertElementHasText()	0	8	2
A	assertPageHasText()	0	10	2
A	assertPageNotHasText()	0	9	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

<?php

namespace Magium;

use Facebook\WebDriver\Exception\NoSuchElementException;
use Facebook\WebDriver\Exception\WebDriverException;
use Magium\Assertions\Element\Clickable;
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\TestCase\Initializer;
use Magium\Themes\BaseThemeInterface;
use Magium\Util\Log\Logger;
use Magium\Util\Phpunit\MasterListener;
use Magium\WebDriver\WebDriver;
use PHPUnit_Framework_TestResult;
use Zend\Di\Di;

abstract class AbstractTestCase extends \PHPUnit_Framework_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';

    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');
        $init = new Initializer();
        $init->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()
    {
        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)
    {
        if (!$initializer instanceof Initializer) {
            $initializer = new Initializer();
        }
        $this->initializer = $initializer;
        self::getMasterListener();
        parent::__construct($name, $data, $dataName);

    }

    public function setTestResultObject(PHPUnit_Framework_TestResult $result)
    {
        // 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

        self::getMasterListener()->bindToResult($result);
        parent::setTestResultObject($result);
    }

    /**
     * @return MasterListener
     */

    public static function getMasterListener()
    {
        if (!self::$masterListener instanceof MasterListener) {
            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) {
            $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($namespace, $class) === 0) {
                // We have a fully qualified class name
                return $class;
            }
        }

        foreach (self::$baseNamespaces as $namespace) {
            $fqClass = $namespace . '\\' . $class;
            if (class_exists($fqClass)) {
                return $fqClass;
            }
        }
        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\Magento\Identities\AbstractEntity
     */

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

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

    /**
     *
     * @param string $navigator
     * @return \Magium\Magento\Navigators\BaseMenuNavigator
     */

    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('Magium\Commands\Open')->open($url);
    }


    /**
     * @return \Magium\Util\Log\Logger
     */

    public function getLogger()
    {
        return $this->get('Magium\Util\Log\Logger');
    }

    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 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, NotDisplayed::ASSERTION);
    }

    public function assertElementNotDisplayed($selector, $by = 'byId')
    {
        try {
            $this->assertElementExists($selector, $by);
            self::assertFalse(
                $this->webdriver->$by($selector)->isDisplayed(),
                sprintf('The element: %s, is displayed and it should not have been', $selector)
            );
        } catch (\Exception $e) {
            $this->fail(sprintf('Element "%s" cannot be found using selector "%s"', $selector, $by));
        }
    }

    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(Logger::CHARACTERISTIC_THEME, $fullyQualifiedClassName);
    }

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

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

    public function assertPageHasText($text)
    {
        try {
            $this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
            // If the element is not found then an exception will be thrown
        } 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
        }
    }

    /**
     * @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);
    }
}