| <?php |
| /** |
| * PHPUnit |
| * |
| * Copyright (c) 2002-2008, Sebastian Bergmann <sb@sebastian-bergmann.de>. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * * Neither the name of Sebastian Bergmann nor the names of his |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| * @category Testing |
| * @package PHPUnit |
| * @author Sebastian Bergmann <sb@sebastian-bergmann.de> |
| * @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de> |
| * @license http://www.opensource.org/licenses/bsd-license.php BSD License |
| * @version SVN: $Id: SeleniumTestCase.php 2111 2008-01-15 09:55:15Z sb $ |
| * @link http://www.phpunit.de/ |
| * @since File available since Release 3.0.0 |
| */ |
| |
| require_once 'PHPUnit/Framework.php'; |
| require_once 'PHPUnit/Util/Log/Database.php'; |
| require_once 'PHPUnit/Util/Filter.php'; |
| require_once 'PHPUnit/Util/Test.php'; |
| require_once 'PHPUnit/Util/XML.php'; |
| |
| PHPUnit_Util_Filter::addFileToFilter(__FILE__, 'PHPUNIT'); |
| |
| /** |
| * TestCase class that uses Selenium to provide |
| * the functionality required for web testing. |
| * |
| * @category Testing |
| * @package PHPUnit |
| * @author Sebastian Bergmann <sb@sebastian-bergmann.de> |
| * @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de> |
| * @license http://www.opensource.org/licenses/bsd-license.php BSD License |
| * @version Release: 3.2.9 |
| * @link http://www.phpunit.de/ |
| * @since Class available since Release 3.0.0 |
| */ |
| abstract class PHPUnit_Extensions_SeleniumTestCase extends PHPUnit_Framework_TestCase { |
| /** |
| * @var array |
| * @access public |
| * @static |
| */ |
| public static $browsers = array(); |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $browser; |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $browserName; |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $browserUrl; |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $host = 'localhost'; |
| |
| /** |
| * @var integer |
| * @access protected |
| */ |
| protected $port = 4444; |
| |
| /** |
| * @var integer |
| * @access protected |
| */ |
| protected $timeout = 30000; |
| |
| /** |
| * @var array |
| * @access protected |
| */ |
| protected static $sessionId = array(); |
| |
| /** |
| * @var integer |
| * @access protected |
| */ |
| protected $sleep = 0; |
| |
| /** |
| * @var boolean |
| * @access protected |
| */ |
| protected $autoStop = TRUE; |
| |
| /** |
| * @var boolean |
| * @access protected |
| */ |
| protected $collectCodeCoverageInformation = FALSE; |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $coverageScriptUrl = ''; |
| |
| /** |
| * @var string |
| * @access protected |
| */ |
| protected $testId; |
| |
| /** |
| * @var boolean |
| * @access protected |
| */ |
| protected $inDefaultAssertions = FALSE; |
| |
| /** |
| * @param string $name |
| * @param array $browser |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function __construct($name = NULL, array $data = array(), array $browser = array()) { |
| parent::__construct($name, $data); |
| |
| if (isset($browser['name'])) { |
| if (! is_string($browser['name'])) { |
| throw new InvalidArgumentException(); |
| } |
| } else { |
| $browser['name'] = ''; |
| } |
| |
| if (isset($browser['browser'])) { |
| if (! is_string($browser['browser'])) { |
| throw new InvalidArgumentException(); |
| } |
| } else { |
| $browser['browser'] = ''; |
| } |
| |
| if (isset($browser['host'])) { |
| if (! is_string($browser['host'])) { |
| throw new InvalidArgumentException(); |
| } |
| } else { |
| $browser['host'] = 'localhost'; |
| } |
| |
| if (isset($browser['port'])) { |
| if (! is_int($browser['port'])) { |
| throw new InvalidArgumentException(); |
| } |
| } else { |
| $browser['port'] = 4444; |
| } |
| |
| if (isset($browser['timeout'])) { |
| if (! is_int($browser['timeout'])) { |
| throw new InvalidArgumentException(); |
| } |
| } else { |
| $browser['timeout'] = 30000; |
| } |
| |
| $this->browserName = $browser['name']; |
| $this->browser = $browser['browser']; |
| $this->host = $browser['host']; |
| $this->port = $browser['port']; |
| $this->timeout = $browser['timeout']; |
| } |
| |
| /** |
| * @param string $className |
| * @return PHPUnit_Framework_TestSuite |
| * @access public |
| */ |
| public static function suite($className) { |
| $suite = new PHPUnit_Framework_TestSuite(); |
| $suite->setName($className); |
| |
| $class = new ReflectionClass($className); |
| $classGroups = PHPUnit_Util_Test::getGroups($class); |
| $staticProperties = $class->getStaticProperties(); |
| |
| // Create tests from Selenese/HTML files. |
| if (isset($staticProperties['seleneseDirectory']) && is_dir($staticProperties['seleneseDirectory'])) { |
| $files = new PHPUnit_Util_FilterIterator(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($staticProperties['seleneseDirectory'])), '.htm'); |
| |
| // Create tests from Selenese/HTML files for multiple browsers. |
| if (! empty($staticProperties['browsers'])) { |
| foreach ($staticProperties['browsers'] as $browser) { |
| $browserSuite = new PHPUnit_Framework_TestSuite(); |
| $browserSuite->setName($className . ': ' . $browser['name']); |
| |
| foreach ($files as $file) { |
| $browserSuite->addTest(new $className((string)$file, array(), $browser)); |
| } |
| |
| $suite->addTest($browserSuite, $classGroups); |
| } |
| } |
| |
| // Create tests from Selenese/HTML files for single browser. |
| else { |
| foreach ($files as $file) { |
| $suite->addTest(new $className((string)$file), $classGroups); |
| } |
| } |
| } |
| |
| // Create tests from test methods for multiple browsers. |
| if (! empty($staticProperties['browsers'])) { |
| foreach ($staticProperties['browsers'] as $browser) { |
| $browserSuite = new PHPUnit_Framework_TestSuite(); |
| $browserSuite->setName($className . ': ' . $browser['name']); |
| |
| foreach ($class->getMethods() as $method) { |
| if (PHPUnit_Framework_TestSuite::isPublicTestMethod($method)) { |
| $name = $method->getName(); |
| $data = PHPUnit_Util_Test::getProvidedData($className, $name); |
| $groups = PHPUnit_Util_Test::getGroups($method, $classGroups); |
| |
| // Test method with @dataProvider. |
| if (is_array($data) || $data instanceof Iterator) { |
| $dataSuite = new PHPUnit_Framework_TestSuite($className . '::' . $name); |
| |
| foreach ($data as $_data) { |
| $dataSuite->addTest(new $className($name, $_data, $browser), $groups); |
| } |
| |
| $browserSuite->addTest($dataSuite); |
| } |
| |
| // Test method without @dataProvider. |
| else { |
| $browserSuite->addTest(new $className($name, array(), $browser), $groups); |
| } |
| } |
| } |
| |
| $suite->addTest($browserSuite); |
| } |
| } |
| |
| // Create tests from test methods for single browser. |
| else { |
| foreach ($class->getMethods() as $method) { |
| if (PHPUnit_Framework_TestSuite::isPublicTestMethod($method)) { |
| $name = $method->getName(); |
| $data = PHPUnit_Util_Test::getProvidedData($className, $name); |
| $groups = PHPUnit_Util_Test::getGroups($method, $classGroups); |
| |
| // Test method with @dataProvider. |
| if (is_array($data) || $data instanceof Iterator) { |
| $dataSuite = new PHPUnit_Framework_TestSuite($className . '::' . $name); |
| |
| foreach ($data as $_data) { |
| $dataSuite->addTest(new $className($name, $_data), $groups); |
| } |
| |
| $suite->addTest($dataSuite); |
| } |
| |
| // Test method without @dataProvider. |
| else { |
| $suite->addTest(new $className($name), $groups); |
| } |
| } |
| } |
| } |
| |
| return $suite; |
| } |
| |
| /** |
| * Runs the test case and collects the results in a TestResult object. |
| * If no TestResult object is passed a new one will be created. |
| * |
| * @param PHPUnit_Framework_TestResult $result |
| * @return PHPUnit_Framework_TestResult |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function run(PHPUnit_Framework_TestResult $result = NULL) { |
| if ($result === NULL) { |
| $result = $this->createResult(); |
| } |
| |
| $this->collectCodeCoverageInformation = $result->getCollectCodeCoverageInformation(); |
| |
| $result->run($this); |
| |
| if ($this->collectCodeCoverageInformation) { |
| $result->appendCodeCoverageInformation($this, $this->getCodeCoverage()); |
| } |
| |
| return $result; |
| } |
| |
| /** |
| * @access protected |
| */ |
| protected function runTest() { |
| $this->start(); |
| |
| if (! is_file($this->name)) { |
| parent::runTest(); |
| } else { |
| $this->runSelenese($this->name); |
| } |
| |
| if ($this->autoStop) { |
| try { |
| $this->stop(); |
| } |
| |
| catch (RuntimeException $e) {} |
| } |
| } |
| |
| /** |
| * If you want to override tearDown() make sure to either call stop() or |
| * parent::tearDown(). Otherwise the Selenium RC session will not be |
| * closed upon test failure. |
| * |
| * @access protected |
| */ |
| protected function tearDown() { |
| if ($this->autoStop) { |
| try { |
| $this->stop(); |
| } |
| |
| catch (RuntimeException $e) {} |
| } |
| } |
| |
| /** |
| * Returns a string representation of the test case. |
| * |
| * @return string |
| * @access public |
| */ |
| public function toString() { |
| $buffer = parent::toString(); |
| |
| if (! empty($this->browserName)) { |
| $buffer .= ' with browser ' . $this->browserName; |
| } |
| |
| return $buffer; |
| } |
| |
| /** |
| * @return string |
| * @access public |
| */ |
| public function start() { |
| if (! isset(self::$sessionId[$this->host][$this->port][$this->browser])) { |
| self::$sessionId[$this->host][$this->port][$this->browser] = $this->getString('getNewBrowserSession', array( |
| $this->browser, $this->browserUrl)); |
| |
| $this->doCommand('setTimeout', array($this->timeout)); |
| } |
| |
| $this->testId = md5(uniqid(rand(), TRUE)); |
| |
| return self::$sessionId[$this->host][$this->port][$this->browser]; |
| } |
| |
| /** |
| * @access public |
| */ |
| public function stop() { |
| if (! isset(self::$sessionId[$this->host][$this->port][$this->browser])) { |
| return; |
| } |
| |
| $this->doCommand('testComplete'); |
| |
| unset(self::$sessionId[$this->host][$this->port][$this->browser]); |
| } |
| |
| /** |
| * @param boolean $autoStop |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setAutoStop($autoStop) { |
| if (! is_bool($autoStop)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->autoStop = $autoStop; |
| } |
| |
| /** |
| * @param string $browser |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setBrowser($browser) { |
| if (! is_string($browser)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->browser = $browser; |
| } |
| |
| /** |
| * @param string $browserUrl |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setBrowserUrl($browserUrl) { |
| if (! is_string($browserUrl)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->browserUrl = $browserUrl; |
| } |
| |
| /** |
| * @param string $host |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setHost($host) { |
| if (! is_string($host)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->host = $host; |
| } |
| |
| /** |
| * @param integer $port |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setPort($port) { |
| if (! is_int($port)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->port = $port; |
| } |
| |
| /** |
| * @param integer $timeout |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setTimeout($timeout) { |
| if (! is_int($timeout)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->timeout = $timeout; |
| } |
| |
| /** |
| * @param integer $seconds |
| * @throws InvalidArgumentException |
| * @access public |
| */ |
| public function setSleep($seconds) { |
| if (! is_int($seconds)) { |
| throw new InvalidArgumentException(); |
| } |
| |
| $this->sleep = $seconds; |
| } |
| |
| /** |
| * Runs a test from a Selenese (HTML) specification. |
| * |
| * @param string $filename |
| * @access public |
| */ |
| public function runSelenese($filename) { |
| $document = PHPUnit_Util_XML::load($filename, TRUE); |
| $xpath = new DOMXPath($document); |
| $rows = $xpath->query('body/table/tbody/tr'); |
| |
| foreach ($rows as $row) { |
| $action = NULL; |
| $arguments = array(); |
| $columns = $xpath->query('td', $row); |
| |
| foreach ($columns as $column) { |
| if ($action === NULL) { |
| $action = $column->nodeValue; |
| } else { |
| $arguments[] = $column->nodeValue; |
| } |
| } |
| |
| $this->__call($action, $arguments); |
| } |
| } |
| |
| /** |
| * This method implements the Selenium RC protocol. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return mixed |
| * @access public |
| * @method unknown addLocationStrategy() |
| * @method unknown addSelection() |
| * @method unknown allowNativeXpath() |
| * @method unknown altKeyDown() |
| * @method unknown altKeyUp() |
| * @method unknown answerOnNextPrompt() |
| * @method unknown assignId() |
| * @method unknown captureScreenshot() |
| * @method unknown check() |
| * @method unknown chooseCancelOnNextConfirmation() |
| * @method unknown click() |
| * @method unknown clickAndWait() |
| * @method unknown clickAt() |
| * @method unknown close() |
| * @method unknown controlKeyDown() |
| * @method unknown controlKeyUp() |
| * @method unknown createCookie() |
| * @method unknown deleteCookie() |
| * @method unknown doubleClick() |
| * @method unknown doubleClickAt() |
| * @method unknown dragAndDrop() |
| * @method unknown dragAndDropToObject() |
| * @method unknown dragDrop() |
| * @method unknown fireEvent() |
| * @method string getAlert() |
| * @method array getAllButtons() |
| * @method array getAllFields() |
| * @method array getAllLinks() |
| * @method array getAllWindowIds() |
| * @method array getAllWindowNames() |
| * @method array getAllWindowTitles() |
| * @method string getAttribute() |
| * @method array getAttributeFromAllWindows() |
| * @method string getBodyText() |
| * @method string getConfirmation() |
| * @method string getCookie() |
| * @method integer getCursorPosition() |
| * @method integer getElementHeight() |
| * @method integer getElementIndex() |
| * @method integer getElementPositionLeft() |
| * @method integer getElementPositionTop() |
| * @method integer getElementWidth() |
| * @method string getEval() |
| * @method string getExpression() |
| * @method string getHtmlSource() |
| * @method string getLocation() |
| * @method string getLogMessages() |
| * @method integer getMouseSpeed() |
| * @method string getPrompt() |
| * @method array getSelectOptions() |
| * @method string getSelectedId() |
| * @method array getSelectedIds() |
| * @method string getSelectedIndex() |
| * @method array getSelectedIndexes() |
| * @method string getSelectedLabel() |
| * @method array getSelectedLabels() |
| * @method string getSelectedValue() |
| * @method array getSelectedValues() |
| * @method unknown getSpeed() |
| * @method string getTable() |
| * @method string getText() |
| * @method string getTitle() |
| * @method string getValue() |
| * @method boolean getWhetherThisFrameMatchFrameExpression() |
| * @method boolean getWhetherThisWindowMatchWindowExpression() |
| * @method integer getXpathCount() |
| * @method unknown goBack() |
| * @method unknown highlight() |
| * @method boolean isAlertPresent() |
| * @method boolean isChecked() |
| * @method boolean isConfirmationPresent() |
| * @method boolean isEditable() |
| * @method boolean isElementPresent() |
| * @method boolean isOrdered() |
| * @method boolean isPromptPresent() |
| * @method boolean isSomethingSelected() |
| * @method boolean isTextPresent() |
| * @method boolean isVisible() |
| * @method unknown keyDown() |
| * @method unknown keyPress() |
| * @method unknown keyUp() |
| * @method unknown metaKeyDown() |
| * @method unknown metaKeyUp() |
| * @method unknown mouseDown() |
| * @method unknown mouseDownAt() |
| * @method unknown mouseMove() |
| * @method unknown mouseMoveAt() |
| * @method unknown mouseOut() |
| * @method unknown mouseOver() |
| * @method unknown mouseUp() |
| * @method unknown mouseUpAt() |
| * @method unknown open() |
| * @method unknown openWindow() |
| * @method unknown refresh() |
| * @method unknown removeAllSelections() |
| * @method unknown removeSelection() |
| * @method unknown select() |
| * @method unknown selectFrame() |
| * @method unknown selectWindow() |
| * @method unknown setContext() |
| * @method unknown setCursorPosition() |
| * @method unknown setMouseSpeed() |
| * @method unknown setSpeed() |
| * @method unknown shiftKeyDown() |
| * @method unknown shiftKeyUp() |
| * @method unknown submit() |
| * @method unknown type() |
| * @method unknown typeKeys() |
| * @method unknown uncheck() |
| * @method unknown waitForCondition() |
| * @method unknown waitForPageToLoad() |
| * @method unknown waitForPopUp() |
| * @method unknown windowFocus() |
| * @method unknown windowMaximize() |
| */ |
| public function __call($command, $arguments) { |
| switch ($command) { |
| case 'addLocationStrategy': |
| case 'addSelection': |
| case 'allowNativeXpath': |
| case 'altKeyDown': |
| case 'altKeyUp': |
| case 'answerOnNextPrompt': |
| case 'assignId': |
| case 'captureScreenshot': |
| case 'check': |
| case 'chooseCancelOnNextConfirmation': |
| case 'click': |
| case 'clickAt': |
| case 'close': |
| case 'controlKeyDown': |
| case 'controlKeyUp': |
| case 'createCookie': |
| case 'deleteCookie': |
| case 'doubleClick': |
| case 'doubleClickAt': |
| case 'dragAndDrop': |
| case 'dragAndDropToObject': |
| case 'dragDrop': |
| case 'fireEvent': |
| case 'goBack': |
| case 'highlight': |
| case 'keyDown': |
| case 'keyPress': |
| case 'keyUp': |
| case 'metaKeyDown': |
| case 'metaKeyUp': |
| case 'mouseDown': |
| case 'mouseDownAt': |
| case 'mouseMove': |
| case 'mouseMoveAt': |
| case 'mouseOut': |
| case 'mouseOver': |
| case 'mouseUp': |
| case 'mouseUpAt': |
| case 'open': |
| case 'openWindow': |
| case 'refresh': |
| case 'removeAllSelections': |
| case 'removeSelection': |
| case 'select': |
| case 'selectFrame': |
| case 'selectWindow': |
| case 'setContext': |
| case 'setCursorPosition': |
| case 'setMouseSpeed': |
| case 'setSpeed': |
| case 'shiftKeyDown': |
| case 'shiftKeyUp': |
| case 'submit': |
| case 'type': |
| case 'typeKeys': |
| case 'uncheck': |
| case 'windowFocus': |
| case 'windowMaximize': |
| { |
| // Pre-Command Actions |
| switch ($command) { |
| case 'open': |
| case 'openWindow': |
| { |
| if ($this->collectCodeCoverageInformation) { |
| $this->deleteCookie('PHPUNIT_SELENIUM_TEST_ID', '/'); |
| |
| $this->createCookie('PHPUNIT_SELENIUM_TEST_ID=' . $this->testId, 'path=/'); |
| } |
| } |
| break; |
| } |
| |
| $this->doCommand($command, $arguments); |
| |
| // Post-Command Actions |
| switch ($command) { |
| case 'addLocationStrategy': |
| case 'allowNativeXpath': |
| case 'assignId': |
| case 'captureScreenshot': |
| { // intentionally empty |
| } |
| break; |
| |
| default: |
| { |
| if ($this->sleep > 0) { |
| sleep($this->sleep); |
| } |
| |
| $this->runDefaultAssertions($command); |
| } |
| } |
| } |
| break; |
| |
| case 'getWhetherThisFrameMatchFrameExpression': |
| case 'getWhetherThisWindowMatchWindowExpression': |
| case 'isAlertPresent': |
| case 'isChecked': |
| case 'isConfirmationPresent': |
| case 'isEditable': |
| case 'isElementPresent': |
| case 'isOrdered': |
| case 'isPromptPresent': |
| case 'isSomethingSelected': |
| case 'isTextPresent': |
| case 'isVisible': |
| { |
| return $this->getBoolean($command, $arguments); |
| } |
| break; |
| |
| case 'getCursorPosition': |
| case 'getElementHeight': |
| case 'getElementIndex': |
| case 'getElementPositionLeft': |
| case 'getElementPositionTop': |
| case 'getElementWidth': |
| case 'getMouseSpeed': |
| case 'getSpeed': |
| case 'getXpathCount': |
| { |
| return $this->getNumber($command, $arguments); |
| } |
| break; |
| |
| case 'getAlert': |
| case 'getAttribute': |
| case 'getBodyText': |
| case 'getConfirmation': |
| case 'getCookie': |
| case 'getEval': |
| case 'getExpression': |
| case 'getHtmlSource': |
| case 'getLocation': |
| case 'getLogMessages': |
| case 'getPrompt': |
| case 'getSelectedId': |
| case 'getSelectedIndex': |
| case 'getSelectedLabel': |
| case 'getSelectedValue': |
| case 'getTable': |
| case 'getText': |
| case 'getTitle': |
| case 'getValue': |
| { |
| return $this->getString($command, $arguments); |
| } |
| break; |
| |
| case 'getAllButtons': |
| case 'getAllFields': |
| case 'getAllLinks': |
| case 'getAllWindowIds': |
| case 'getAllWindowNames': |
| case 'getAllWindowTitles': |
| case 'getAttributeFromAllWindows': |
| case 'getSelectedIds': |
| case 'getSelectedIndexes': |
| case 'getSelectedLabels': |
| case 'getSelectedValues': |
| case 'getSelectOptions': |
| { |
| return $this->getStringArray($command, $arguments); |
| } |
| break; |
| |
| case 'clickAndWait': |
| { |
| $this->doCommand('click', $arguments); |
| $this->doCommand('waitForPageToLoad', array($this->timeout)); |
| |
| if ($this->sleep > 0) { |
| sleep($this->sleep); |
| } |
| |
| $this->runDefaultAssertions($command); |
| } |
| break; |
| |
| case 'waitForCondition': |
| case 'waitForPopUp': |
| { |
| if (count($arguments) == 1) { |
| $arguments[] = $this->timeout; |
| } |
| |
| $this->doCommand($command, $arguments); |
| $this->runDefaultAssertions($command); |
| } |
| break; |
| |
| case 'waitForPageToLoad': |
| { |
| if (empty($arguments)) { |
| $arguments[] = $this->timeout; |
| } |
| |
| $this->doCommand($command, $arguments); |
| $this->runDefaultAssertions($command); |
| } |
| break; |
| |
| default: |
| { |
| $this->stop(); |
| |
| throw new BadMethodCallException("Method $command not defined."); |
| } |
| } |
| } |
| |
| /** |
| * Asserts that an alert is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertAlertPresent($message = 'No alert present.') { |
| $this->assertTrue($this->isAlertPresent(), $message); |
| } |
| |
| /** |
| * Asserts that no alert is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertNoAlertPresent($message = 'Alert present.') { |
| $this->assertFalse($this->isAlertPresent(), $message); |
| } |
| |
| /** |
| * Asserts that an option is checked. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertChecked($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" not checked.', $locator); |
| } |
| |
| $this->assertTrue($this->isChecked($locator), $message); |
| } |
| |
| /** |
| * Asserts that an option is not checked. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertNotChecked($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" checked.', $locator); |
| } |
| |
| $this->assertFalse($this->isChecked($locator), $message); |
| } |
| |
| /** |
| * Assert that a confirmation is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertConfirmationPresent($message = 'No confirmation present.') { |
| $this->assertTrue($this->isConfirmationPresent(), $message); |
| } |
| |
| /** |
| * Assert that no confirmation is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertNoConfirmationPresent($message = 'Confirmation present.') { |
| $this->assertFalse($this->isConfirmationPresent(), $message); |
| } |
| |
| /** |
| * Asserts that an input field is editable. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertEditable($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" not editable.', $locator); |
| } |
| |
| $this->assertTrue($this->isEditable($locator), $message); |
| } |
| |
| /** |
| * Asserts that an input field is not editable. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertNotEditable($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" editable.', $locator); |
| } |
| |
| $this->assertFalse($this->isEditable($locator), $message); |
| } |
| |
| /** |
| * Asserts that an element's value is equal to a given string. |
| * |
| * @param string $locator |
| * @param string $text |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementValueEquals($locator, $text, $message = '') { |
| $this->assertEquals($text, $this->getValue($locator), $message); |
| } |
| |
| /** |
| * Asserts that an element's value is not equal to a given string. |
| * |
| * @param string $locator |
| * @param string $text |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementValueNotEquals($locator, $text, $message = '') { |
| $this->assertNotEquals($text, $this->getValue($locator), $message); |
| } |
| |
| /** |
| * Asserts that an element contains a given string. |
| * |
| * @param string $locator |
| * @param string $text |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementContainsText($locator, $text, $message = '') { |
| $this->assertContains($text, $this->getValue($locator), $message); |
| } |
| |
| /** |
| * Asserts that an element does not contain a given string. |
| * |
| * @param string $locator |
| * @param string $text |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementNotContainsText($locator, $text, $message = '') { |
| $this->assertNotContains($text, $this->getValue($locator), $message); |
| } |
| |
| /** |
| * Asserts than an element is present. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementPresent($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Element "%s" not present.', $locator); |
| } |
| |
| $this->assertTrue($this->isElementPresent($locator), $message); |
| } |
| |
| /** |
| * Asserts than an element is not present. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertElementNotPresent($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Element "%s" present.', $locator); |
| } |
| |
| $this->assertFalse($this->isElementPresent($locator), $message); |
| } |
| |
| /** |
| * Asserts that the location is equal to a specified one. |
| * |
| * @param string $location |
| * @param string $message |
| * @access public |
| */ |
| public function assertLocationEquals($location, $message = '') { |
| $this->assertEquals($location, $this->getLocation(), $message); |
| } |
| |
| /** |
| * Asserts that the location is not equal to a specified one. |
| * |
| * @param string $location |
| * @param string $message |
| * @access public |
| */ |
| public function assertLocationNotEquals($location, $message = '') { |
| $this->assertNotEquals($location, $this->getLocation(), $message); |
| } |
| |
| /** |
| * Asserts than a prompt is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertPromptPresent($message = 'No prompt present.') { |
| $this->assertTrue($this->isPromptPresent(), $message); |
| } |
| |
| /** |
| * Asserts than no prompt is present. |
| * |
| * @param string $message |
| * @access public |
| */ |
| public function assertNoPromptPresent($message = 'Prompt present.') { |
| $this->assertFalse($this->isPromptPresent(), $message); |
| } |
| |
| /** |
| * Asserts that a select element has a specific option. |
| * |
| * @param string $selectLocator |
| * @param string $option |
| * @param string $message |
| * @access public |
| * @since Method available since Release 3.2.0 |
| */ |
| public function assertSelectHasOption($selectLocator, $option, $message = '') { |
| $this->assertContains($option, $this->getSelectOptions($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a select element does not have a specific option. |
| * |
| * @param string $selectLocator |
| * @param string $option |
| * @param string $message |
| * @access public |
| * @since Method available since Release 3.2.0 |
| */ |
| public function assertSelectNotHasOption($selectLocator, $option, $message = '') { |
| $this->assertNotContains($option, $this->getSelectOptions($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a specific label is selected. |
| * |
| * @param string $selectLocator |
| * @param string $value |
| * @param string $message |
| * @access public |
| * @since Method available since Release 3.2.0 |
| */ |
| public function assertSelected($selectLocator, $option, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Label "%s" not selected in "%s".', $option, $selectLocator); |
| } |
| |
| $this->assertEquals($option, $this->getSelectedLabel($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a specific label is not selected. |
| * |
| * @param string $selectLocator |
| * @param string $value |
| * @param string $message |
| * @access public |
| * @since Method available since Release 3.2.0 |
| */ |
| public function assertNotSelected($selectLocator, $option, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Label "%s" selected in "%s".', $option, $selectLocator); |
| } |
| |
| $this->assertNotEquals($option, $this->getSelectedLabel($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a specific value is selected. |
| * |
| * @param string $selectLocator |
| * @param string $value |
| * @param string $message |
| * @access public |
| */ |
| public function assertIsSelected($selectLocator, $value, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Value "%s" not selected in "%s".', $value, $selectLocator); |
| } |
| |
| $this->assertEquals($value, $this->getSelectedValue($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a specific value is not selected. |
| * |
| * @param string $selectLocator |
| * @param string $value |
| * @param string $message |
| * @access public |
| */ |
| public function assertIsNotSelected($selectLocator, $value, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Value "%s" selected in "%s".', $value, $selectLocator); |
| } |
| |
| $this->assertNotEquals($value, $this->getSelectedValue($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that something is selected. |
| * |
| * @param string $selectLocator |
| * @param string $message |
| * @access public |
| */ |
| public function assertSomethingSelected($selectLocator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Nothing selected from "%s".', $selectLocator); |
| } |
| |
| $this->assertTrue($this->isSomethingSelected($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that nothing is selected. |
| * |
| * @param string $selectLocator |
| * @param string $message |
| * @access public |
| */ |
| public function assertNothingSelected($selectLocator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('Something selected from "%s".', $selectLocator); |
| } |
| |
| $this->assertFalse($this->isSomethingSelected($selectLocator), $message); |
| } |
| |
| /** |
| * Asserts that a given text is present. |
| * |
| * @param string $pattern |
| * @param string $message |
| * @access public |
| */ |
| public function assertTextPresent($pattern, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" not present.', $pattern); |
| } |
| |
| $this->assertTrue($this->isTextPresent($pattern), $message); |
| } |
| |
| /** |
| * Asserts that a given text is not present. |
| * |
| * @param string $pattern |
| * @param string $message |
| * @access public |
| */ |
| public function assertTextNotPresent($pattern, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" present.', $pattern); |
| } |
| |
| $this->assertFalse($this->isTextPresent($pattern), $message); |
| } |
| |
| /** |
| * Asserts that the title is equal to a given string. |
| * |
| * @param string $title |
| * @param string $message |
| * @access public |
| */ |
| public function assertTitleEquals($title, $message = '') { |
| $this->assertEquals($title, $this->getTitle(), $message); |
| } |
| |
| /** |
| * Asserts that the title is not equal to a given string. |
| * |
| * @param string $title |
| * @param string $message |
| * @access public |
| */ |
| public function assertTitleNotEquals($title, $message = '') { |
| $this->assertNotEquals($title, $this->getTitle(), $message); |
| } |
| |
| /** |
| * Asserts that something is visible. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertVisible($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" not visible.', $locator); |
| } |
| |
| $this->assertTrue($this->isVisible($locator), $message); |
| } |
| |
| /** |
| * Asserts that something is not visible. |
| * |
| * @param string $locator |
| * @param string $message |
| * @access public |
| */ |
| public function assertNotVisible($locator, $message = '') { |
| if ($message == '') { |
| $message = sprintf('"%s" visible.', $locator); |
| } |
| |
| $this->assertFalse($this->isVisible($locator), $message); |
| } |
| |
| /** |
| * Template Method that is called after Selenium actions. |
| * |
| * @param string $action |
| * @access protected |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function defaultAssertions($action) {} |
| |
| /** |
| * Send a command to the Selenium RC server. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return string |
| * @access protected |
| * @author Shin Ohno <ganchiku@gmail.com> |
| * @author Bjoern Schotte <schotte@mayflower.de> |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function doCommand($command, array $arguments = array()) { |
| $url = sprintf('http://%s:%s/selenium-server/driver/?cmd=%s', $this->host, $this->port, urlencode($command)); |
| |
| for ($i = 0; $i < count($arguments); $i ++) { |
| $argNum = strval($i + 1); |
| $url .= sprintf('&%s=%s', $argNum, urlencode(trim($arguments[$i]))); |
| } |
| |
| if (isset(self::$sessionId[$this->host][$this->port][$this->browser])) { |
| $url .= sprintf('&%s=%s', 'sessionId', self::$sessionId[$this->host][$this->port][$this->browser]); |
| } |
| |
| if (! $handle = @fopen($url, 'r')) { |
| throw new RuntimeException('Could not connect to the Selenium RC server.'); |
| } |
| |
| stream_set_blocking($handle, 1); |
| stream_set_timeout($handle, 0, $this->timeout); |
| |
| $info = stream_get_meta_data($handle); |
| $response = ''; |
| |
| while ((! feof($handle)) && (! $info['timed_out'])) { |
| $response .= fgets($handle, 4096); |
| $info = stream_get_meta_data($handle); |
| } |
| |
| fclose($handle); |
| |
| if (! preg_match('/^OK/', $response)) { |
| $this->stop(); |
| |
| throw new RuntimeException('The response from the Selenium RC server is invalid: ' . $response); |
| } |
| |
| return $response; |
| } |
| |
| /** |
| * Send a command to the Selenium RC server and treat the result |
| * as a boolean. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return boolean |
| * @access protected |
| * @author Shin Ohno <ganchiku@gmail.com> |
| * @author Bjoern Schotte <schotte@mayflower.de> |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function getBoolean($command, array $arguments) { |
| $result = $this->getString($command, $arguments); |
| |
| switch ($result) { |
| case 'true': |
| return TRUE; |
| |
| case 'false': |
| return FALSE; |
| |
| default: |
| { |
| $this->stop(); |
| |
| throw new RuntimeException('Result is neither "true" nor "false": ' . PHPUnit_Util_Type::toString($result, TRUE)); |
| } |
| } |
| } |
| |
| /** |
| * Send a command to the Selenium RC server and treat the result |
| * as a number. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return numeric |
| * @access protected |
| * @author Shin Ohno <ganchiku@gmail.com> |
| * @author Bjoern Schotte <schotte@mayflower.de> |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function getNumber($command, array $arguments) { |
| $result = $this->getString($command, $arguments); |
| |
| if (! is_numeric($result)) { |
| $this->stop(); |
| |
| throw new RuntimeException('Result is not numeric: ' . PHPUnit_Util_Type::toString($result, TRUE)); |
| } |
| |
| return $result; |
| } |
| |
| /** |
| * Send a command to the Selenium RC server and treat the result |
| * as a string. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return string |
| * @access protected |
| * @author Shin Ohno <ganchiku@gmail.com> |
| * @author Bjoern Schotte <schotte@mayflower.de> |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function getString($command, array $arguments) { |
| try { |
| $result = $this->doCommand($command, $arguments); |
| } |
| |
| catch (RuntimeException $e) { |
| $this->stop(); |
| |
| throw $e; |
| } |
| |
| return (strlen($result) > 3) ? substr($result, 3) : ''; |
| } |
| |
| /** |
| * Send a command to the Selenium RC server and treat the result |
| * as an array of strings. |
| * |
| * @param string $command |
| * @param array $arguments |
| * @return array |
| * @access protected |
| * @author Shin Ohno <ganchiku@gmail.com> |
| * @author Bjoern Schotte <schotte@mayflower.de> |
| * @since Method available since Release 3.1.0 |
| */ |
| protected function getStringArray($command, array $arguments) { |
| $csv = $this->getString($command, $arguments); |
| $token = ''; |
| $tokens = array(); |
| $letters = preg_split('//', $csv, - 1, PREG_SPLIT_NO_EMPTY); |
| $count = count($letters); |
| |
| for ($i = 0; $i < $count; $i ++) { |
| $letter = $letters[$i]; |
| |
| switch ($letter) { |
| case '\\': |
| { |
| $letter = $letters[++ $i]; |
| $token .= $letter; |
| } |
| break; |
| |
| case ',': |
| { |
| $tokens[] = $token; |
| $token = ''; |
| } |
| break; |
| |
| default: |
| { |
| $token .= $letter; |
| } |
| } |
| } |
| |
| $tokens[] = $token; |
| |
| return $tokens; |
| } |
| |
| /** |
| * @return array |
| * @access protected |
| * @since Method available since Release 3.2.0 |
| */ |
| protected function getCodeCoverage() { |
| if (! empty($this->coverageScriptUrl)) { |
| $url = sprintf('%s?PHPUNIT_SELENIUM_TEST_ID=%s', $this->coverageScriptUrl, $this->testId); |
| |
| return $this->matchLocalAndRemotePaths(eval('return ' . file_get_contents($url) . ';')); |
| } else { |
| return array(); |
| } |
| } |
| |
| /** |
| * @param array $coverage |
| * @return array |
| * @access protected |
| * @author Mattis Stordalen Flister <mattis@xait.no> |
| * @since Method available since Release 3.2.9 |
| */ |
| protected function matchLocalAndRemotePaths(array &$coverage) { |
| $coverageWithLocalPaths = array(); |
| |
| foreach ($coverage as $originalRemotePath => $value) { |
| $remotePath = $originalRemotePath; |
| $separator = $this->findDirectorySeparator($remotePath); |
| |
| while (! ($localpath = PHPUnit_Util_Filesystem::fileExistsInIncludePath($remotePath)) && strpos($remotePath, $separator) !== FALSE) { |
| $remotePath = substr($remotePath, strpos($remotePath, $separator) + 1); |
| } |
| |
| if ($localpath && md5_file($localpath) == $value['md5']) { |
| $coverageWithLocalPaths[$localpath] = $value; |
| unset($coverageWithLocalPaths[$localpath]['md5']); |
| } |
| } |
| |
| return $coverageWithLocalPaths; |
| } |
| |
| /** |
| * @param string $path |
| * @return string |
| * @access protected |
| * @author Mattis Stordalen Flister <mattis@xait.no> |
| * @since Method available since Release 3.2.9 |
| */ |
| protected function findDirectorySeparator($path) { |
| if (strpos($path, '/') !== FALSE) { |
| return '/'; |
| } |
| |
| return '\\'; |
| } |
| |
| /** |
| * @param string $path |
| * @return array |
| * @access protected |
| * @author Mattis Stordalen Flister <mattis@xait.no> |
| * @since Method available since Release 3.2.9 |
| */ |
| protected function explodeDirectories($path) { |
| return explode($this->findDirectorySeparator($path), dirname($path)); |
| } |
| |
| /** |
| * @param string $action |
| * @access private |
| * @since Method available since Release 3.2.0 |
| */ |
| private function runDefaultAssertions($action) { |
| if (! $this->inDefaultAssertions) { |
| $this->inDefaultAssertions = TRUE; |
| $this->defaultAssertions($action); |
| $this->inDefaultAssertions = FALSE; |
| } |
| } |
| } |
| ?> |
