AbstractTestCase::assertElementDisplayed() - Code Metrics - Inspection of "Merge pull request #100 from kschroeder/master" - magium/Magium - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9ad6b1...7b0007 )

by Kevin

created 2016-03-25 16:33 UTC

AbstractTestCase::assertElementDisplayed() A

↳ Parent: AbstractTestCase

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
nc	1
cc	1
eloc	2
nop	2

<?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\Themes\ThemeConfigurationInterface;
use Magium\Util\Api\Request;
use Magium\Util\Configuration\ClassConfigurationReader;
use Magium\Util\Configuration\ConfigurationCollector\DefaultPropertyCollector;
use Magium\Util\Configuration\ConfigurationReader;
use Magium\Util\Configuration\EnvironmentConfigurationReader;
use Magium\Util\Configuration\StandardConfigurationProvider;
use Magium\Util\Log\Logger;
use Magium\Util\Api\Clairvoyant\Clairvoyant;
use Magium\Util\Phpunit\MasterListener;
use Magium\Util\TestCase\RegistrationListener;
use Magium\WebDriver\LoggingRemoteExecuteMethod;
use Magium\WebDriver\WebDriver;
use PHPUnit_Framework_TestResult;
use Zend\Di\Config;
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 $testCaseConfiguration = 'Magium\TestCaseConfiguration';

    protected $testCaseConfigurationObject;

    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($this->testCaseConfiguration, $this->testCaseConfigurationObject);
        $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 __construct($name = null, array $data = [], $dataName = null, TestCaseConfiguration $configuration = null)
    {
        $this->testCaseConfigurationObject = $configuration;
        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 function setTestCaseConfigurationClass($class)
    {
        $this->testCaseConfiguration = $class;
    }

    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);
    }
}


1			<?php
2
3			namespace Magium;
4
5			use Facebook\WebDriver\Exception\NoSuchElementException;
6			use Facebook\WebDriver\Exception\WebDriverException;
7			use Magium\Assertions\Element\Clickable;
8			use Magium\Assertions\Element\Exists;
9			use Magium\Assertions\Element\NotClickable;
10			use Magium\Assertions\Element\NotDisplayed;
11			use Magium\Assertions\Element\NotExists;
12			use Magium\Assertions\LoggingAssertionExecutor;
13			use Magium\TestCase\Initializer;
14			use Magium\Themes\BaseThemeInterface;
15			use Magium\Themes\ThemeConfigurationInterface;
16			use Magium\Util\Api\Request;
17			use Magium\Util\Configuration\ClassConfigurationReader;
18			use Magium\Util\Configuration\ConfigurationCollector\DefaultPropertyCollector;
19			use Magium\Util\Configuration\ConfigurationReader;
20			use Magium\Util\Configuration\EnvironmentConfigurationReader;
21			use Magium\Util\Configuration\StandardConfigurationProvider;
22			use Magium\Util\Log\Logger;
23			use Magium\Util\Api\Clairvoyant\Clairvoyant;
24			use Magium\Util\Phpunit\MasterListener;
25			use Magium\Util\TestCase\RegistrationListener;
26			use Magium\WebDriver\LoggingRemoteExecuteMethod;
27			use Magium\WebDriver\WebDriver;
28			use PHPUnit_Framework_TestResult;
29			use Zend\Di\Config;
30			use Zend\Di\Di;
31
32			abstract class AbstractTestCase extends \PHPUnit_Framework_TestCase
33			{
34
35			protected static $baseNamespaces = [];
36
37			protected $baseThemeClass = 'Magium\Themes\ThemeConfigurationInterface';
38
39			protected $postCallbacks = [];
40
41			/**
42			* @var MasterListener
43			*/
44
45			protected static $masterListener;
46
47			/**
48			* @var \Magium\WebDriver\WebDriver
49			*/
50			protected $webdriver;
51
52			/**
53			* @var Di
54			*/
55
56			protected $di;
57
58			protected $textElementNodeSearch = [
59			'button', 'span', 'a', 'li', 'label', 'option', 'h1', 'h2', 'h3', 'td'
60			];
61
62			protected $testCaseConfiguration = 'Magium\TestCaseConfiguration';
63
64			protected $testCaseConfigurationObject;
65
66			const BY_XPATH = 'byXpath';
67			const BY_ID = 'byId';
68			const BY_CSS_SELECTOR = 'byCssSelector';
69			const BY_TEXT = 'byText';
70
71			protected static $registrationCallbacks;
72
73			protected function setUp()
74			{
75			/*
76			* Putting this in the setup and not in the property means that an extending class can inject itself easily
77			* before the Magium namespace, thus, taking preference over the base namespace
78			*/
79			self::addBaseNamespace('Magium');
80			$init = new Initializer($this->testCaseConfiguration, $this->testCaseConfigurationObject);
81			$init->initialize($this);
82			}
83
84			/**
85			* @return Di
86			*/
87			public function getDi()
88			{
89			return $this->di;
90			}
91
92			/**
93			* @param Di $di
94			*/
95			public function setDi($di)
96			{
97			$this->di = $di;
98			}
99
100			/**
101			* @return WebDriver
102			*/
103			public function getWebdriver()
104			{
105			return $this->webdriver;
106			}
107
108			/**
109			* @param WebDriver $webdriver
110			*/
111			public function setWebdriver(WebDriver $webdriver)
112			{
113			$this->webdriver = $webdriver;
114			}
115
116
117			public function __construct($name = null, array $data = [], $dataName = null, TestCaseConfiguration $configuration = null)
118			{
119			$this->testCaseConfigurationObject = $configuration;
120			self::getMasterListener();
121			parent::__construct($name, $data, $dataName);
122
123			}
124
125			public function setTestResultObject(PHPUnit_Framework_TestResult $result)
126			{
127			// This odd little function is here because the first place where you can reliably add a listener without
128			// having to make a phpunit.xml or program argument change
129
130			self::getMasterListener()->bindToResult($result);
131			parent::setTestResultObject($result);
132			}
133
134			/**
135			* @return MasterListener
136			*/
137
138			public static function getMasterListener()
139			{
140			if (!self::$masterListener instanceof MasterListener) {
141			self::$masterListener = new MasterListener();
142			}
143			return self::$masterListener;
144			}
145
146			protected function tearDown()
147			{
148			foreach ($this->postCallbacks as $callback) {
149			if (is_callable($callback)) {
150			call_user_func($callback);
151			}
152			}
153			parent::tearDown();
154			if ($this->webdriver instanceof WebDriver) {
155			$this->webdriver->quit();
156			$this->webdriver = null;
157			}
158			}
159
160
161			public function filterWebDriverAction($by)
162			{
163			switch ($by) {
164			case WebDriver::BY_XPATH:
165			return 'xpath';
166			case WebDriver::BY_CSS_SELECTOR:
167			return 'css_selector';
168			case WebDriver::BY_ID:
169			return 'id';
170			default:
171			return $by;
172			}
173			}
174
175			public function assertElementClickable($selector, $by = WebDriver::BY_ID)
176			{
177			$this->elementAssertion($selector, $by, Clickable::ASSERTION);
178			}
179
180
181			public function assertElementNotClickable($selector, $by = WebDriver::BY_ID)
182			{
183			$this->elementAssertion($selector, $by, NotClickable::ASSERTION);
184
185			}
186
187			public function setTestCaseConfigurationClass($class)
188			{
189			$this->testCaseConfiguration = $class;
190			}
191
192			public static function addBaseNamespace($namespace)
193			{
194			if (!in_array($namespace, self::$baseNamespaces)) {
195			self::$baseNamespaces[] = trim($namespace, '\\');
196			}
197			}
198
199			public static function resolveClass( $class, $prefix = null)
200			{
201			$origClass = $class;
202			if ($prefix !== null) {
203			$class = "{$prefix}\\{$class}";
204			}
205			foreach (self::$baseNamespaces as $namespace) {
206			if (strpos($namespace, $class) === 0) {
207			// We have a fully qualified class name
208			return $class;
209			}
210			}
211
212			foreach (self::$baseNamespaces as $namespace) {
213			$fqClass = $namespace . '\\' . $class;
214			if (class_exists($fqClass)) {
215			return $fqClass;
216			}
217			}
218			return $origClass;
219			}
220
221			public function setTypePreference($type, $preference)
222			{
223			$type = self::resolveClass($type);
224			$preference = self::resolveClass($preference);
225			$this->di->instanceManager()->unsetTypePreferences($type);
226			$this->di->instanceManager()->setTypePreference($type, [$preference]);
227
228			}
229
230			protected function normalizeClassRequest($class)
231			{
232			return str_replace('/', '\\', $class);
233			}
234
235			public function addPostTestCallback($callback)
236			{
237			if (!is_callable($callback)) {
238			throw new InvalidConfigurationException('Callback is not callable');
239			}
240			$this->postCallbacks[] = $callback;
241			}
242
243			/**
244
245			* @param string $theme
246			* @return \Magium\Themes\ThemeConfigurationInterface
247			*/
248
249			public function getTheme($theme = null)
250			{
251			if ($theme === null) {
252			return $this->get($this->baseThemeClass);
253			}
254			$theme = self::resolveClass($theme, 'Themes');
255			return $this->get($theme);
256			}
257
258			/**
259			*
260			* @param string $action
261			* @return mixed
262			*/
263
264			public function getAction($action)
265			{
266			$action = self::resolveClass($action, 'Actions');
267
268			return $this->get($action);
269			}
270
271
272			/**
273			* @param string $name
274			* @return \Magium\Magento\Identities\AbstractEntity
275			*/
276
277			public function getIdentity($name = 'Customer')
278			{
279			$name = self::resolveClass($name, 'Identities');
280
281			return $this->get($name);
282			}
283
284			/**
285			*
286			* @param string $navigator
287			* @return \Magium\Magento\Navigators\BaseMenuNavigator
288			*/
289
290			public function getNavigator($navigator = 'BaseMenu')
291			{
292			$navigator = self::resolveClass($navigator, 'Navigators');
293
294			return $this->get($navigator);
295			}
296
297			public function getAssertion($assertion)
298			{
299			$assertion = self::resolveClass($assertion, 'Assertions');
300
301			return $this->get($assertion);
302			}
303
304			/**
305			*
306			* @param string $extractor
307			* @return \Magium\Extractors\AbstractExtractor
308			*/
309
310			public function getExtractor($extractor)
311			{
312			$extractor = self::resolveClass($extractor, 'Extractors');
313
314			return $this->get($extractor);
315			}
316
317			/**
318			* Sleep the specified amount of time.
319			*
320			* Options: 1s (1 second), 1ms (1 millisecond), 1us (1 microsecond), 1ns (1 nanosecond)
321			*
322			* @param $time
323			*/
324
325			public function sleep($time)
326			{
327			$length = (int)$time;
328
329			if (strpos($time, 'ms') !== false) {
330			usleep($length * 1000);
331			} else if (strpos($time, 'us') !== false) {
332			usleep($length);
333			} else if (strpos($time, 'ns') !== false) {
334			time_nanosleep(0, $length);
335			} else {
336			sleep($length);
337			}
338			}
339
340
341			public function commandOpen($url)
342			{
343			$this->get('Magium\Commands\Open')->open($url);
344			}
345
346
347			/**
348			* @return \Magium\Util\Log\Logger
349			*/
350
351			public function getLogger()
352			{
353			return $this->get('Magium\Util\Log\Logger');
354			}
355
356			public function get($class)
357			{
358			$class = $this->normalizeClassRequest($class);
359			$preferredClass = $this->di->instanceManager()->getTypePreferences($class);
360			if (is_array($preferredClass) && count($preferredClass) > 0) {
361			$class = array_shift($preferredClass);
362			}
363			return $this->di->get($class);
364			}
365
366
367			public function assertElementExists($selector, $by = 'byId')
368			{
369			$this->elementAssertion($selector, $by, Exists::ASSERTION);
370			}
371
372			public function assertTitleEquals($title)
373			{
374			$webTitle = $this->webdriver->getTitle();
375			self::assertEquals($title, $webTitle);
376			}
377
378
379			public function assertTitleContains($title)
380			{
381			$webTitle = $this->webdriver->getTitle();
382			self::assertContains($title, $webTitle);
383			}
384
385
386			public function assertNotTitleEquals($title)
387			{
388			$webTitle = $this->webdriver->getTitle();
389			self::assertNotEquals($title, $webTitle);
390			}
391
392
393			public function assertNotTitleContains($title)
394			{
395			$webTitle = $this->webdriver->getTitle();
396			self::assertNotContains($title, $webTitle);
397			}
398
399			public function assertURLEquals($url)
400			{
401			$webUrl = $this->webdriver->getCurrentURL();
402			self::assertEquals($url, $webUrl);
403			}
404
405			public function assertURLContains($url)
406			{
407			$webUrl = $this->webdriver->getCurrentURL();
408			self::assertContains($url, $webUrl);
409			}
410
411
412			public function assertURLNotEquals($url)
413			{
414			$webUrl = $this->webdriver->getCurrentURL();
415			self::assertNotEquals($url, $webUrl);
416			}
417
418			public function assertURLNotContains($url)
419			{
420			$webUrl = $this->webdriver->getCurrentURL();
421			self::assertNotContains($url, $webUrl);
422			}
423
424			protected function elementAssertion($selector, $by, $name)
425			{
426			$executor = $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
427			$assertion = $this->getAssertion($name);
428			$assertion->setSelector($selector)->setBy($by);
429			$executor->execute($assertion);
430			}
431
432			public function assertElementDisplayed($selector, $by = 'byId')
433			{
434			$this->elementAssertion($selector, $by, NotDisplayed::ASSERTION);
435			}
436
437			public function assertElementNotDisplayed($selector, $by = 'byId')
438			{
439			try {
440			$this->assertElementExists($selector, $by);
441			self::assertFalse(
442			$this->webdriver->$by($selector)->isDisplayed(),
443			sprintf('The element: %s, is displayed and it should not have been', $selector)
444			);
445			} catch (\Exception $e) {
446			$this->fail(sprintf('Element "%s" cannot be found using selector "%s"', $selector, $by));
447			}
448			}
449
450			public function assertElementNotExists($selector, $by = 'byId')
451			{
452			$this->elementAssertion($selector, $by, NotExists::ASSERTION);
453			}
454
455			/**
456			* @return LoggingAssertionExecutor
457			*/
458
459			public function getAssertionLogger()
460			{
461			return $this->getAssertion(LoggingAssertionExecutor::ASSERTION);
462			}
463
464			public function switchThemeConfiguration($fullyQualifiedClassName)
465			{
466
467			$reflection = new \ReflectionClass($fullyQualifiedClassName);
468
469			if ($reflection->implementsInterface('Magium\Themes\ThemeConfigurationInterface')) {
470			$this->baseThemeClass = $fullyQualifiedClassName;
471			$this->di->instanceManager()->unsetTypePreferences('Magium\Themes\ThemeConfigurationInterface');
472			$this->di->instanceManager()->setTypePreference('Magium\Themes\ThemeConfigurationInterface', [$fullyQualifiedClassName]);
473
474			if ($reflection->implementsInterface('Magium\Themes\BaseThemeInterface')) {
475			$this->di->instanceManager()->unsetTypePreferences('Magium\Themes\BaseThemeInterface');
476			$this->di->instanceManager()->setTypePreference('Magium\Themes\BaseThemeInterface', [$fullyQualifiedClassName]);
477			}
478			$theme = $this->getTheme();
479			if ($theme instanceof BaseThemeInterface) {
480			$theme->configure($this);
481			}
482			} else {
483			throw new InvalidConfigurationException('The theme configuration implement Magium\Themes\ThemeConfigurationInterface');
484			}
485			$this->getLogger()->addCharacteristic(Logger::CHARACTERISTIC_THEME, $fullyQualifiedClassName);
486			}
487
488			public static function assertWebDriverElement($element)
489			{
490			self::assertInstanceOf('Facebook\WebDriver\WebDriverElement', $element);
491			}
492
493			public function assertElementHasText($node, $text)
494			{
495			try {
496			$this->byXpath(sprintf('//%s[contains(., "%s")]', $node, addslashes($text)));
497			} catch (\Exception $e) {
498			$this->fail('The body did not contain the text: ' . $text);
499			}
500			}
501
502			public function assertPageHasText($text)
503			{
504			try {
505			$this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
506			// If the element is not found then an exception will be thrown
507			} catch (\Exception $e) {
508			$this->fail('The body did not contain the text: ' . $text);
509			}
510
511			}
512
513			public function assertPageNotHasText($text)
514			{
515			try {
516			$this->webdriver->byXpath(sprintf('//body[contains(., "%s")]', $text));
517			$this->fail('The page contains the words: ' . $text);
518			} catch (NoSuchElementException $e) {
519			// Exception thrown is a success
520			}
521			}
522
523			/**
524			* @param $xpath
525			* @return \Facebook\WebDriver\Remote\RemoteWebElement
526			*/
527
528			public function byXpath($xpath)
529			{
530			return $this->webdriver->byXpath($xpath);
531			}
532
533			/**
534			* @param $id
535			* @return \Facebook\WebDriver\Remote\RemoteWebElement
536			*/
537
538			public function byId($id)
539			{
540			return $this->webdriver->byId($id);
541			}
542
543			/**
544			* @param $selector
545			* @return \Facebook\WebDriver\Remote\RemoteWebElement
546			*/
547
548			public function byCssSelector($selector)
549			{
550			return $this->webdriver->byCssSelector($selector);
551			}
552
553			protected function getElementByTextXpath($xpathTemplate, $text, $specificNodeType = null, $parentElementSelector = null)
554			{
555
556			if ($parentElementSelector !== null) {
557			$xpathTemplate = $parentElementSelector . $xpathTemplate;
558			}
559			if ($specificNodeType !== null) {
560			return $this->byXpath(sprintf($xpathTemplate, $specificNodeType, $this->getTranslator()->translatePlaceholders($text)));
561			}
562
563			foreach ($this->textElementNodeSearch as $nodeName) {
564			$xpath = sprintf($xpathTemplate, $nodeName, $this->getTranslator()->translatePlaceholders($text));
565			if ($this->webdriver->elementExists($xpath, WebDriver::BY_XPATH)) {
566			return $this->webdriver->byXpath($xpath);
567			}
568			}
569			// This is here for consistency with the other by* methods
570			WebDriverException::throwException(7, 'Could not find element with text: ' . $this->getTranslator()->translatePlaceholders($text), []);
571			}
572
573			/**
574			* @param string $text
575			* @param string $specificNodeType
576			* @param string $parentElementSelector
577			* @return \Facebook\WebDriver\Remote\RemoteWebElement
578			*/
579			public function byText($text, $specificNodeType = null, $parentElementSelector = null)
580			{
581			$xpathTemplate = '//%s[concat(" ",normalize-space(.)," ") = " %s "]';
582			return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
583			}
584
585
586			/**
587			* @param string $text
588			* @param string $specificNodeType
589			* @param string $parentElementSelector
590			* @return \Facebook\WebDriver\Remote\RemoteWebElement
591			*/
592			public function byContainsText($text, $specificNodeType = null, $parentElementSelector = null)
593			{
594			$xpathTemplate = '//%s[contains(., "%s")]';
595			return $this->getElementByTextXpath($xpathTemplate, $text, $specificNodeType, $parentElementSelector);
596			}
597
598			/**
599			* @return \Magium\Util\Translator\Translator
600			*/
601
602			public function getTranslator()
603			{
604			return $this->get('Magium\Util\Translator\Translator');
605			}
606
607			public function addTranslationCsvFile($file, $locale)
608			{
609			$this->getTranslator()->addTranslationCsvFile($file, $locale);
610			}
611			}
612

magium / Magium

Push — master ( 9ad6b1...7b0007 )

AbstractTestCase::assertElementDisplayed() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like