C:/xampp/htdocs/moodle/lib/simpletestlib/web_tester.php

Go to the documentation of this file.

<?php
require_once(dirname(__FILE__) . '/test_case.php');
require_once(dirname(__FILE__) . '/browser.php');
require_once(dirname(__FILE__) . '/page.php');
require_once(dirname(__FILE__) . '/expectation.php');
class FieldExpectation extends SimpleExpectation {
    var $_value;
    
    function FieldExpectation($value, $message = '%s') {
        $this->SimpleExpectation($message);
        if (is_array($value)) {
            sort($value);
        }
        $this->_value = $value;
    }
    
    function test($compare) {
        if ($this->_value === false) {
            return ($compare === false);
        }
        if ($this->_isSingle($this->_value)) {
            return $this->_testSingle($compare);
        }
        if (is_array($this->_value)) {
            return $this->_testMultiple($compare);
        }
        return false;
    }
    
    function _isSingle($value) {
        return is_string($value) || is_integer($value) || is_float($value);
    }
    
    function _testSingle($compare) {
        if (is_array($compare) && count($compare) == 1) {
            $compare = $compare[0];
        }
        if (! $this->_isSingle($compare)) {
            return false;
        }
        return ($this->_value == $compare);
    }
    
    function _testMultiple($compare) {
        if (is_string($compare)) {
            $compare = array($compare);
        }
        if (! is_array($compare)) {
            return false;
        }
        sort($compare);
        return ($this->_value === $compare);
    }
    
    function testMessage($compare) {
        $dumper = &$this->_getDumper();
        if (is_array($compare)) {
            sort($compare);
        }
        if ($this->test($compare)) {
            return "Field expectation [" . $dumper->describeValue($this->_value) . "]";
        } else {
            return "Field expectation [" . $dumper->describeValue($this->_value) .
                    "] fails with [" .
                    $dumper->describeValue($compare) . "] " .
                    $dumper->describeDifference($this->_value, $compare);
        }
    }
}

class HttpHeaderExpectation extends SimpleExpectation {
    var $_expected_header;
    var $_expected_value;
    
    function HttpHeaderExpectation($header, $value = false, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_expected_header = $this->_normaliseHeader($header);
        $this->_expected_value = $value;
    }
    
    function _getExpectation() {
        return $this->_expected_value;
    }
    
    function _normaliseHeader($header) {
        return strtolower(trim($header));
    }
    
    function test($compare) {
        return is_string($this->_findHeader($compare));
    }
    
    function _findHeader($compare) {
        $lines = explode("\r\n", $compare);
        foreach ($lines as $line) {
            if ($this->_testHeaderLine($line)) {
                return $line;
            }
        }
        return false;
    }
    
    function _testHeaderLine($line) {
        if (count($parsed = explode(':', $line, 2)) < 2) {
            return false;
        }
        list($header, $value) = $parsed;
        if ($this->_normaliseHeader($header) != $this->_expected_header) {
            return false;
        }
        return $this->_testHeaderValue($value, $this->_expected_value);
    }
    
    function _testHeaderValue($value, $expected) {
        if ($expected === false) {
            return true;
        }
        if (SimpleExpectation::isExpectation($expected)) {
            return $expected->test(trim($value));
        }
        return (trim($value) == trim($expected));
    }
    
    function testMessage($compare) {
        if (SimpleExpectation::isExpectation($this->_expected_value)) {
            $message = $this->_expected_value->overlayMessage($compare, $this->_getDumper());
        } else {
            $message = $this->_expected_header .
                    ($this->_expected_value ? ': ' . $this->_expected_value : '');
        }
        if (is_string($line = $this->_findHeader($compare))) {
            return "Searching for header [$message] found [$line]";
        } else {
            return "Failed to find header [$message]";
        }
    }
}
    
class NoHttpHeaderExpectation extends HttpHeaderExpectation {
    var $_expected_header;
    var $_expected_value;
    
    function NoHttpHeaderExpectation($unwanted, $message = '%s') {
        $this->HttpHeaderExpectation($unwanted, false, $message);
    }
    
    function test($compare) {
        return ($this->_findHeader($compare) === false);
    }
    
    function testMessage($compare) {
        $expectation = $this->_getExpectation();
        if (is_string($line = $this->_findHeader($compare))) {
            return "Found unwanted header [$expectation] with [$line]";
        } else {
            return "Did not find unwanted header [$expectation]";
        }
    }
}

class TextExpectation extends SimpleExpectation {
    var $_substring;
    
    function TextExpectation($substring, $message = '%s') {
        $this->SimpleExpectation($message);
        $this->_substring = $substring;
    }
    
    function _getSubstring() {
        return $this->_substring;
    }
    
    function test($compare) {
        return (strpos($compare, $this->_substring) !== false);
    }
    
    function testMessage($compare) {
        if ($this->test($compare)) {
            return $this->_describeTextMatch($this->_getSubstring(), $compare);
        } else {
            $dumper = &$this->_getDumper();
            return "Text [" . $this->_getSubstring() .
                    "] not detected in [" .
                    $dumper->describeValue($compare) . "]";
        }
    }
    
    function _describeTextMatch($substring, $subject) {
        $position = strpos($subject, $substring);
        $dumper = &$this->_getDumper();
        return "Text [$substring] detected at character [$position] in [" .
                $dumper->describeValue($subject) . "] in region [" .
                $dumper->clipString($subject, 100, $position) . "]";
    }
}

class NoTextExpectation extends TextExpectation {
    
    function NoTextExpectation($substring, $message = '%s') {
        $this->TextExpectation($substring, $message);
    }
    
    function test($compare) {
        return ! parent::test($compare);
    }
    
    function testMessage($compare) {
        if ($this->test($compare)) {
            $dumper = &$this->_getDumper();
            return "Text [" . $this->_getSubstring() .
                    "] not detected in [" .
                    $dumper->describeValue($compare) . "]";
        } else {
            return $this->_describeTextMatch($this->_getSubstring(), $compare);
        }
    }
}

class WebTestCase extends SimpleTestCase {
    var $_browser;
    var $_ignore_errors = false;
    
    function WebTestCase($label = false) {
        $this->SimpleTestCase($label);
    }
    
    function before($method) {
        parent::before($method);
        $this->setBrowser($this->createBrowser());
    }

    function after($method) {
        $this->unsetBrowser();
        parent::after($method);
    }
    
    function &getBrowser() {
        return $this->_browser;
    }
    
    function setBrowser(&$browser) {
        return $this->_browser = &$browser;
    }
        
    function unsetBrowser() {
        unset($this->_browser);
    }
    
    function &createBrowser() {
        $browser = new SimpleBrowser();
        return $browser;
    }
    
    function getTransportError() {
        return $this->_browser->getTransportError();
    }
        
    function getUrl() {
        return $this->_browser->getUrl();
    }
    
    function showRequest() {
        $this->dump($this->_browser->getRequest());
    }
    
    function showHeaders() {
        $this->dump($this->_browser->getHeaders());
    }
    
    function showSource() {
        $this->dump($this->_browser->getContent());
    }
    
    function showText() {
        $this->dump(wordwrap($this->_browser->getContentAsText(), 80));
    }
    
    function restart($date = false) {
        if ($date === false) {
            $date = time();
        }
        $this->_browser->restart($date);
    }
    
    function ageCookies($interval) {
        $this->_browser->ageCookies($interval);
    }
    
    function ignoreFrames() {
        $this->_browser->ignoreFrames();
    }
    
    function ignoreCookies() {
        $this->_browser->ignoreCookies();
    }
    
    function ignoreErrors() {
        $this->_ignore_errors = true;
    }
    
    function _failOnError($result) {
        if (! $this->_ignore_errors) {
            if ($error = $this->_browser->getTransportError()) {
                $this->fail($error);
            }
        }
        $this->_ignore_errors = false;
        return $result;
    }

    function addHeader($header) {
        $this->_browser->addHeader($header);
    }
    
    function setMaximumRedirects($max) {
        if (! $this->_browser) {
            trigger_error(
                    'Can only set maximum redirects in a test method, setUp() or tearDown()');
        }
        $this->_browser->setMaximumRedirects($max);
    }
    
    function setConnectionTimeout($timeout) {
        $this->_browser->setConnectionTimeout($timeout);
    }
    
    function useProxy($proxy, $username = false, $password = false) {
        $this->_browser->useProxy($proxy, $username, $password);
    }
    
    function get($url, $parameters = false) {
        return $this->_failOnError($this->_browser->get($url, $parameters));
    }
    
    function post($url, $parameters = false) {
        return $this->_failOnError($this->_browser->post($url, $parameters));
    }
    
    function head($url, $parameters = false) {
        return $this->_failOnError($this->_browser->head($url, $parameters));
    }
    
    function retry() {
        return $this->_failOnError($this->_browser->retry());
    }
    
    function back() {
        return $this->_failOnError($this->_browser->back());
    }
    
    function forward() {
        return $this->_failOnError($this->_browser->forward());
    }
    
    function authenticate($username, $password) {
        return $this->_failOnError(
                $this->_browser->authenticate($username, $password));
    }
    
    function getCookie($name) {
        return $this->_browser->getCurrentCookieValue($name);
    }
    
    function setCookie($name, $value, $host = false, $path = '/', $expiry = false) {
        $this->_browser->setCookie($name, $value, $host, $path, $expiry);
    }
    
    function getFrameFocus() {
        return $this->_browser->getFrameFocus();
    }
    
    function setFrameFocusByIndex($choice) {
        return $this->_browser->setFrameFocusByIndex($choice);
    }
    
    function setFrameFocus($name) {
        return $this->_browser->setFrameFocus($name);
    }
    
    function clearFrameFocus() {
        return $this->_browser->clearFrameFocus();
    }
    
    function click($label) {
        return $this->_failOnError($this->_browser->click($label));
    }
    
    function assertClickable($label, $message = '%s') {
        return $this->assertTrue(
                $this->_browser->isClickable($label),
                sprintf($message, "Click target [$label] should exist"));
    }
    
    function clickSubmit($label = 'Submit', $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickSubmit($label, $additional));
    }
    
    function clickSubmitByName($name, $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickSubmitByName($name, $additional));
    }
    
    function clickSubmitById($id, $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickSubmitById($id, $additional));
    }
    
    function assertSubmit($label, $message = '%s') {
        return $this->assertTrue(
                $this->_browser->isSubmit($label),
                sprintf($message, "Submit button [$label] should exist"));
    }
    
    function clickImage($label, $x = 1, $y = 1, $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickImage($label, $x, $y, $additional));
    }
    
    function clickImageByName($name, $x = 1, $y = 1, $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickImageByName($name, $x, $y, $additional));
    }
    
    function clickImageById($id, $x = 1, $y = 1, $additional = false) {
        return $this->_failOnError(
                $this->_browser->clickImageById($id, $x, $y, $additional));
    }
    
    function assertImage($label, $message = '%s') {
        return $this->assertTrue(
                $this->_browser->isImage($label),
                sprintf($message, "Image with text [$label] should exist"));
    }
    
    function submitFormById($id) {
        return $this->_failOnError($this->_browser->submitFormById($id));
    }
    
    function clickLink($label, $index = 0) {
        return $this->_failOnError($this->_browser->clickLink($label, $index));
    }
    
    function clickLinkById($id) {
        return $this->_failOnError($this->_browser->clickLinkById($id));
    }
    
    function assertLink($label, $expected = true, $message = '%s') {
        $url = $this->_browser->getLink($label);
        if ($expected === true || ($expected !== true && $url === false)) {
            return $this->assertTrue($url !== false, sprintf($message, "Link [$label] should exist"));
        }
        if (! SimpleExpectation::isExpectation($expected)) {
            $expected = new IdenticalExpectation($expected);
        }
        return $this->assert($expected, $url->asString(), sprintf($message, "Link [$label] should match"));
    }

    function assertNoLink($label, $message = '%s') {
        return $this->assertTrue(
                $this->_browser->getLink($label) === false,
                sprintf($message, "Link [$label] should not exist"));
    }
    
    function assertLinkById($id, $expected = true, $message = '%s') {
        $url = $this->_browser->getLinkById($id);
        if ($expected === true) {
            return $this->assertTrue($url !== false, sprintf($message, "Link ID [$id] should exist"));
        }
        if (! SimpleExpectation::isExpectation($expected)) {
            $expected = new IdenticalExpectation($expected);
        }
        return $this->assert($expected, $url->asString(), sprintf($message, "Link ID [$id] should match"));
    }

    function assertNoLinkById($id, $message = '%s') {
        return $this->assertTrue(
                $this->_browser->getLinkById($id) === false,
                sprintf($message, "Link ID [$id] should not exist"));
    }
    
    function setField($label, $value, $position=false) {
        return $this->_browser->setField($label, $value, $position);
    }
    
    function setFieldByName($name, $value, $position=false) {
        return $this->_browser->setFieldByName($name, $value, $position);
    }
        
    function setFieldById($id, $value) {
        return $this->_browser->setFieldById($id, $value);
    }
    
    function assertField($label, $expected = true, $message = '%s') {
        $value = $this->_browser->getField($label);
        return $this->_assertFieldValue($label, $value, $expected, $message);
    }
    
    function assertFieldByName($name, $expected = true, $message = '%s') {
        $value = $this->_browser->getFieldByName($name);
        return $this->_assertFieldValue($name, $value, $expected, $message);
    }
        
    function assertFieldById($id, $expected = true, $message = '%s') {
        $value = $this->_browser->getFieldById($id);
        return $this->_assertFieldValue($id, $value, $expected, $message);
    }
    
    function _assertFieldValue($identifier, $value, $expected, $message) {
        if ($expected === true) {
            return $this->assertTrue(
                    isset($value),
                    sprintf($message, "Field [$identifier] should exist"));
        }
        if (! SimpleExpectation::isExpectation($expected)) {
            $identifier = str_replace('%', '%%', $identifier);
            $expected = new FieldExpectation(
                    $expected,
                    "Field [$identifier] should match with [%s]");
        }
        return $this->assert($expected, $value, $message);
    }
    
    function assertResponse($responses, $message = '%s') {
        $responses = (is_array($responses) ? $responses : array($responses));
        $code = $this->_browser->getResponseCode();
        $message = sprintf($message, "Expecting response in [" .
                implode(", ", $responses) . "] got [$code]");
        return $this->assertTrue(in_array($code, $responses), $message);
    }
    
    function assertMime($types, $message = '%s') {
        $types = (is_array($types) ? $types : array($types));
        $type = $this->_browser->getMimeType();
        $message = sprintf($message, "Expecting mime type in [" .
                implode(", ", $types) . "] got [$type]");
        return $this->assertTrue(in_array($type, $types), $message);
    }
    
    function assertAuthentication($authentication = false, $message = '%s') {
        if (! $authentication) {
            $message = sprintf($message, "Expected any authentication type, got [" .
                    $this->_browser->getAuthentication() . "]");
            return $this->assertTrue(
                    $this->_browser->getAuthentication(),
                    $message);
        } else {
            $message = sprintf($message, "Expected authentication [$authentication] got [" .
                    $this->_browser->getAuthentication() . "]");
            return $this->assertTrue(
                    strtolower($this->_browser->getAuthentication()) == strtolower($authentication),
                    $message);
        }
    }
    
    function assertNoAuthentication($message = '%s') {
        $message = sprintf($message, "Expected no authentication type, got [" .
                $this->_browser->getAuthentication() . "]");
        return $this->assertFalse($this->_browser->getAuthentication(), $message);
    }
    
    function assertRealm($realm, $message = '%s') {
        if (! SimpleExpectation::isExpectation($realm)) {
            $realm = new EqualExpectation($realm);
        }
        return $this->assert(
                $realm,
                $this->_browser->getRealm(),
                "Expected realm -> $message");
    }
    
    function assertHeader($header, $value = false, $message = '%s') {
        return $this->assert(
                new HttpHeaderExpectation($header, $value),
                $this->_browser->getHeaders(),
                $message);
    }
        
    function assertHeaderPattern($header, $pattern, $message = '%s') {
        return $this->assert(
                new HttpHeaderExpectation($header, new PatternExpectation($pattern)),
                $this->_browser->getHeaders(),
                $message);
    }

    function assertNoHeader($header, $message = '%s') {
        return $this->assert(
                new NoHttpHeaderExpectation($header),
                $this->_browser->getHeaders(),
                $message);
    }
        
    function assertNoUnwantedHeader($header, $message = '%s') {
        return $this->assertNoHeader($header, $message);
    }
    
    function assertTitle($title = false, $message = '%s') {
        if (! SimpleExpectation::isExpectation($title)) {
            $title = new EqualExpectation($title);
        }
        return $this->assert($title, $this->_browser->getTitle(), $message);
    }
    
    function assertText($text, $message = '%s') {
        return $this->assert(
                new TextExpectation($text),
                $this->_browser->getContentAsText(),
                $message);
    }
    
    function assertWantedText($text, $message = '%s') {
        return $this->assertText($text, $message);
    }
    
    function assertNoText($text, $message = '%s') {
        return $this->assert(
                new NoTextExpectation($text),
                $this->_browser->getContentAsText(),
                $message);
    }
    
    function assertNoUnwantedText($text, $message = '%s') {
        return $this->assertNoText($text, $message);
    }
    
    function assertPattern($pattern, $message = '%s') {
        return $this->assert(
                new PatternExpectation($pattern),
                $this->_browser->getContent(),
                $message);
    }
    
    function assertWantedPattern($pattern, $message = '%s') {
        return $this->assertPattern($pattern, $message);
    }
    
    function assertNoPattern($pattern, $message = '%s') {
        return $this->assert(
                new NoPatternExpectation($pattern),
                $this->_browser->getContent(),
                $message);
    }
    
    function assertNoUnwantedPattern($pattern, $message = '%s') {
        return $this->assertNoPattern($pattern, $message);
    }
    
    function assertCookie($name, $expected = false, $message = '%s') {
        $value = $this->getCookie($name);
        if (! $expected) {
            return $this->assertTrue(
                    $value,
                    sprintf($message, "Expecting cookie [$name]"));
        }
        if (! SimpleExpectation::isExpectation($expected)) {
            $expected = new EqualExpectation($expected);
        }
        return $this->assert($expected, $value, "Expecting cookie [$name] -> $message");
    }
    
    function assertNoCookie($name, $message = '%s') {
        return $this->assertTrue(
                $this->getCookie($name) === false,
                sprintf($message, "Not expecting cookie [$name]"));
    }

    function assertTrue($result, $message = false) {
        return $this->assert(new TrueExpectation(), $result, $message);
    }

    function assertFalse($result, $message = '%s') {
        return $this->assert(new FalseExpectation(), $result, $message);
    }
    
    function assertEqual($first, $second, $message = '%s') {
        return $this->assert(
                new EqualExpectation($first),
                $second,
                $message);
    }
    
    function assertNotEqual($first, $second, $message = '%s') {
        return $this->assert(
                new NotEqualExpectation($first),
                $second,
                $message);
    }

    function getAssertionLine() {
        $trace = new SimpleStackTrace(array('assert', 'click', 'pass', 'fail'));
        return $trace->traceMethod();
    }
}
?>