page_test.php.svn-base

来自「PHP 知识管理系统（基于树结构的知识管理系统）, 英文原版的PHP源码。」· SVN-BASE 代码 · 共 903 行 · 第 1/3 页

<?php
// $Id: page_test.php 1559 2007-07-16 18:13:24Z lastcraft $
require_once(dirname(__FILE__) . '/../autorun.php');
require_once(dirname(__FILE__) . '/../expectation.php');
require_once(dirname(__FILE__) . '/../http.php');
require_once(dirname(__FILE__) . '/../page.php');
require_once(dirname(__FILE__) . '/../parser.php');
Mock::generate('SimpleHtmlSaxParser');
Mock::generate('SimplePage');
Mock::generate('SimpleHttpResponse');
Mock::generate('SimpleHttpHeaders');
Mock::generate('SimplePageBuilder');
Mock::generatePartial(
        'SimplePageBuilder',
        'PartialSimplePageBuilder',
        array('_createPage', '_createParser'));

class TestOfPageBuilder extends UnitTestCase {

    function testLink() {
        $tag = &new SimpleAnchorTag(array('href' => 'http://somewhere'));
        $tag->addContent('Label');

        $page = &new MockSimplePage();
        $page->expectArguments('acceptTag', array($tag));
        $page->expectCallCount('acceptTag', 1);

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $this->assertTrue($builder->startElement(
                'a',
                array('href' => 'http://somewhere')));
        $this->assertTrue($builder->addContent('Label'));
        $this->assertTrue($builder->endElement('a'));
    }

    function testLinkWithId() {
        $tag = &new SimpleAnchorTag(array("href" => "http://somewhere", "id" => "44"));
        $tag->addContent("Label");

        $page = &new MockSimplePage();
        $page->expectArguments("acceptTag", array($tag));
        $page->expectCallCount("acceptTag", 1);

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $this->assertTrue($builder->startElement(
                "a",
                array("href" => "http://somewhere", "id" => "44")));
        $this->assertTrue($builder->addContent("Label"));
        $this->assertTrue($builder->endElement("a"));
    }

    function testLinkExtraction() {
        $tag = &new SimpleAnchorTag(array("href" => "http://somewhere"));
        $tag->addContent("Label");

        $page = &new MockSimplePage();
        $page->expectArguments("acceptTag", array($tag));
        $page->expectCallCount("acceptTag", 1);

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $this->assertTrue($builder->addContent("Starting stuff"));
        $this->assertTrue($builder->startElement(
                "a",
                array("href" => "http://somewhere")));
        $this->assertTrue($builder->addContent("Label"));
        $this->assertTrue($builder->endElement("a"));
        $this->assertTrue($builder->addContent("Trailing stuff"));
    }

    function testMultipleLinks() {
        $a1 = new SimpleAnchorTag(array("href" => "http://somewhere"));
        $a1->addContent("1");

        $a2 = new SimpleAnchorTag(array("href" => "http://elsewhere"));
        $a2->addContent("2");

        $page = &new MockSimplePage();
        $page->expectArgumentsAt(0, "acceptTag", array($a1));
        $page->expectArgumentsAt(1, "acceptTag", array($a2));
        $page->expectCallCount("acceptTag", 2);

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $builder->startElement("a", array("href" => "http://somewhere"));
        $builder->addContent("1");
        $builder->endElement("a");
        $builder->addContent("Padding");
        $builder->startElement("a", array("href" => "http://elsewhere"));
        $builder->addContent("2");
        $builder->endElement("a");
    }

    function testTitle() {
        $tag = &new SimpleTitleTag(array());
        $tag->addContent("HereThere");

        $page = &new MockSimplePage();
        $page->expectArguments("acceptTag", array($tag));
        $page->expectCallCount("acceptTag", 1);

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $builder->startElement("title", array());
        $builder->addContent("Here");
        $builder->addContent("There");
        $builder->endElement("title");
    }

    function testForm() {
        $page = &new MockSimplePage();
        $page->expectOnce("acceptFormStart", array(new SimpleFormTag(array())));
        $page->expectOnce("acceptFormEnd", array());

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
        $builder->SimplePageBuilder();

        $builder->parse(new MockSimpleHttpResponse());
        $builder->startElement("form", array());
        $builder->addContent("Stuff");
        $builder->endElement("form");
    }
}

class TestOfPageParsing extends UnitTestCase {

    function testParseMechanics() {
        $parser = &new MockSimpleHtmlSaxParser();
        $parser->expectOnce('parse', array('stuff'));

        $page = &new MockSimplePage();
        $page->expectOnce('acceptPageEnd');

        $builder = &new PartialSimplePageBuilder();
        $builder->setReturnReference('_createPage', $page);
        $builder->setReturnReference('_createParser', $parser);
        $builder->SimplePageBuilder();

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getContent', 'stuff');
        $builder->parse($response);
    }
}

class TestOfPageInterface extends UnitTestCase {

    function testInterfaceOnEmptyPage() {
        $page = &new SimplePage();
        $this->assertEqual($page->getTransportError(), 'No page fetched yet');
        $this->assertIdentical($page->getRaw(), false);
        $this->assertIdentical($page->getHeaders(), false);
        $this->assertIdentical($page->getMimeType(), false);
        $this->assertIdentical($page->getResponseCode(), false);
        $this->assertIdentical($page->getAuthentication(), false);
        $this->assertIdentical($page->getRealm(), false);
        $this->assertFalse($page->hasFrames());
        $this->assertIdentical($page->getUrls(), array());
        $this->assertIdentical($page->getTitle(), false);
    }
}

class TestOfPageHeaders extends UnitTestCase {

    function testUrlAccessor() {
        $headers = &new MockSimpleHttpHeaders();

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getHeaders', $headers);
        $response->setReturnValue('getMethod', 'POST');
        $response->setReturnValue('getUrl', new SimpleUrl('here'));
        $response->setReturnValue('getRequestData', array('a' => 'A'));

        $page = &new SimplePage($response);
        $this->assertEqual($page->getMethod(), 'POST');
        $this->assertEqual($page->getUrl(), new SimpleUrl('here'));
        $this->assertEqual($page->getRequestData(), array('a' => 'A'));
    }

    function testTransportError() {
        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getError', 'Ouch');

        $page = &new SimplePage($response);
        $this->assertEqual($page->getTransportError(), 'Ouch');
    }

    function testHeadersAccessor() {
        $headers = &new MockSimpleHttpHeaders();
        $headers->setReturnValue('getRaw', 'My: Headers');

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getHeaders', $headers);

        $page = &new SimplePage($response);
        $this->assertEqual($page->getHeaders(), 'My: Headers');
    }

    function testMimeAccessor() {
        $headers = &new MockSimpleHttpHeaders();
        $headers->setReturnValue('getMimeType', 'text/html');

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getHeaders', $headers);

        $page = &new SimplePage($response);
        $this->assertEqual($page->getMimeType(), 'text/html');
    }

    function testResponseAccessor() {
        $headers = &new MockSimpleHttpHeaders();
        $headers->setReturnValue('getResponseCode', 301);

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getHeaders', $headers);

        $page = &new SimplePage($response);
        $this->assertIdentical($page->getResponseCode(), 301);
    }

    function testAuthenticationAccessors() {
        $headers = &new MockSimpleHttpHeaders();
        $headers->setReturnValue('getAuthentication', 'Basic');
        $headers->setReturnValue('getRealm', 'Secret stuff');

        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getHeaders', $headers);

        $page = &new SimplePage($response);
        $this->assertEqual($page->getAuthentication(), 'Basic');
        $this->assertEqual($page->getRealm(), 'Secret stuff');
    }
}

class TestOfHtmlPage extends UnitTestCase {

    function testRawAccessor() {
        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getContent', 'Raw HTML');

        $page = &new SimplePage($response);
        $this->assertEqual($page->getRaw(), 'Raw HTML');
    }

    function testTextAccessor() {
        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getContent', '<b>Some</b> &quot;messy&quot; HTML');

        $page = &new SimplePage($response);
        $this->assertEqual($page->getText(), 'Some "messy" HTML');
    }

    function testNoLinks() {
        $page = &new SimplePage(new MockSimpleHttpResponse());
        $this->assertIdentical($page->getUrls(), array());
        $this->assertIdentical($page->getUrlsByLabel('Label'), array());
    }

    function testAddAbsoluteLink() {
        $link = &new SimpleAnchorTag(array('href' => 'http://somewhere.com'));
        $link->addContent('Label');
        $page = &new SimplePage(new MockSimpleHttpResponse());
        $page->AcceptTag($link);
        $this->assertEqual(
                $page->getUrlsByLabel('Label'),
                array(new SimpleUrl('http://somewhere.com')));
    }

    function testAddStrictRelativeLink() {
        $link = &new SimpleAnchorTag(array('href' => './somewhere.php'));
        $link->addContent('Label');
        $response = &new MockSimpleHttpResponse();
        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
        $page = &new SimplePage($response);
        $page->AcceptTag($link);
        $this->assertEqual(
                $page->getUrlsByLabel('Label'),
                array(new SimpleUrl('http://host/somewhere.php')));