source: trunk/server/www/vendors/simpletest/test/page_test.php @ 6

Last change on this file since 6 was 6, checked in by sander, 11 years ago

Added SimpleTest? test framework

File size: 36.2 KB
Line 
1<?php
2// $Id: page_test.php 1559 2007-07-16 18:13:24Z lastcraft $
3require_once(dirname(__FILE__) . '/../autorun.php');
4require_once(dirname(__FILE__) . '/../expectation.php');
5require_once(dirname(__FILE__) . '/../http.php');
6require_once(dirname(__FILE__) . '/../page.php');
7require_once(dirname(__FILE__) . '/../parser.php');
8Mock::generate('SimpleHtmlSaxParser');
9Mock::generate('SimplePage');
10Mock::generate('SimpleHttpResponse');
11Mock::generate('SimpleHttpHeaders');
12Mock::generate('SimplePageBuilder');
13Mock::generatePartial(
14        'SimplePageBuilder',
15        'PartialSimplePageBuilder',
16        array('_createPage', '_createParser'));
17
18class TestOfPageBuilder extends UnitTestCase {
19
20    function testLink() {
21        $tag = &new SimpleAnchorTag(array('href' => 'http://somewhere'));
22        $tag->addContent('Label');
23
24        $page = &new MockSimplePage();
25        $page->expectArguments('acceptTag', array($tag));
26        $page->expectCallCount('acceptTag', 1);
27
28        $builder = &new PartialSimplePageBuilder();
29        $builder->setReturnReference('_createPage', $page);
30        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
31        $builder->SimplePageBuilder();
32
33        $builder->parse(new MockSimpleHttpResponse());
34        $this->assertTrue($builder->startElement(
35                'a',
36                array('href' => 'http://somewhere')));
37        $this->assertTrue($builder->addContent('Label'));
38        $this->assertTrue($builder->endElement('a'));
39    }
40
41    function testLinkWithId() {
42        $tag = &new SimpleAnchorTag(array("href" => "http://somewhere", "id" => "44"));
43        $tag->addContent("Label");
44
45        $page = &new MockSimplePage();
46        $page->expectArguments("acceptTag", array($tag));
47        $page->expectCallCount("acceptTag", 1);
48
49        $builder = &new PartialSimplePageBuilder();
50        $builder->setReturnReference('_createPage', $page);
51        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
52        $builder->SimplePageBuilder();
53
54        $builder->parse(new MockSimpleHttpResponse());
55        $this->assertTrue($builder->startElement(
56                "a",
57                array("href" => "http://somewhere", "id" => "44")));
58        $this->assertTrue($builder->addContent("Label"));
59        $this->assertTrue($builder->endElement("a"));
60    }
61
62    function testLinkExtraction() {
63        $tag = &new SimpleAnchorTag(array("href" => "http://somewhere"));
64        $tag->addContent("Label");
65
66        $page = &new MockSimplePage();
67        $page->expectArguments("acceptTag", array($tag));
68        $page->expectCallCount("acceptTag", 1);
69
70        $builder = &new PartialSimplePageBuilder();
71        $builder->setReturnReference('_createPage', $page);
72        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
73        $builder->SimplePageBuilder();
74
75        $builder->parse(new MockSimpleHttpResponse());
76        $this->assertTrue($builder->addContent("Starting stuff"));
77        $this->assertTrue($builder->startElement(
78                "a",
79                array("href" => "http://somewhere")));
80        $this->assertTrue($builder->addContent("Label"));
81        $this->assertTrue($builder->endElement("a"));
82        $this->assertTrue($builder->addContent("Trailing stuff"));
83    }
84
85    function testMultipleLinks() {
86        $a1 = new SimpleAnchorTag(array("href" => "http://somewhere"));
87        $a1->addContent("1");
88
89        $a2 = new SimpleAnchorTag(array("href" => "http://elsewhere"));
90        $a2->addContent("2");
91
92        $page = &new MockSimplePage();
93        $page->expectArgumentsAt(0, "acceptTag", array($a1));
94        $page->expectArgumentsAt(1, "acceptTag", array($a2));
95        $page->expectCallCount("acceptTag", 2);
96
97        $builder = &new PartialSimplePageBuilder();
98        $builder->setReturnReference('_createPage', $page);
99        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
100        $builder->SimplePageBuilder();
101
102        $builder->parse(new MockSimpleHttpResponse());
103        $builder->startElement("a", array("href" => "http://somewhere"));
104        $builder->addContent("1");
105        $builder->endElement("a");
106        $builder->addContent("Padding");
107        $builder->startElement("a", array("href" => "http://elsewhere"));
108        $builder->addContent("2");
109        $builder->endElement("a");
110    }
111
112    function testTitle() {
113        $tag = &new SimpleTitleTag(array());
114        $tag->addContent("HereThere");
115
116        $page = &new MockSimplePage();
117        $page->expectArguments("acceptTag", array($tag));
118        $page->expectCallCount("acceptTag", 1);
119
120        $builder = &new PartialSimplePageBuilder();
121        $builder->setReturnReference('_createPage', $page);
122        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
123        $builder->SimplePageBuilder();
124
125        $builder->parse(new MockSimpleHttpResponse());
126        $builder->startElement("title", array());
127        $builder->addContent("Here");
128        $builder->addContent("There");
129        $builder->endElement("title");
130    }
131
132    function testForm() {
133        $page = &new MockSimplePage();
134        $page->expectOnce("acceptFormStart", array(new SimpleFormTag(array())));
135        $page->expectOnce("acceptFormEnd", array());
136
137        $builder = &new PartialSimplePageBuilder();
138        $builder->setReturnReference('_createPage', $page);
139        $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
140        $builder->SimplePageBuilder();
141
142        $builder->parse(new MockSimpleHttpResponse());
143        $builder->startElement("form", array());
144        $builder->addContent("Stuff");
145        $builder->endElement("form");
146    }
147}
148
149class TestOfPageParsing extends UnitTestCase {
150
151    function testParseMechanics() {
152        $parser = &new MockSimpleHtmlSaxParser();
153        $parser->expectOnce('parse', array('stuff'));
154
155        $page = &new MockSimplePage();
156        $page->expectOnce('acceptPageEnd');
157
158        $builder = &new PartialSimplePageBuilder();
159        $builder->setReturnReference('_createPage', $page);
160        $builder->setReturnReference('_createParser', $parser);
161        $builder->SimplePageBuilder();
162
163        $response = &new MockSimpleHttpResponse();
164        $response->setReturnValue('getContent', 'stuff');
165        $builder->parse($response);
166    }
167}
168
169class TestOfPageInterface extends UnitTestCase {
170
171    function testInterfaceOnEmptyPage() {
172        $page = &new SimplePage();
173        $this->assertEqual($page->getTransportError(), 'No page fetched yet');
174        $this->assertIdentical($page->getRaw(), false);
175        $this->assertIdentical($page->getHeaders(), false);
176        $this->assertIdentical($page->getMimeType(), false);
177        $this->assertIdentical($page->getResponseCode(), false);
178        $this->assertIdentical($page->getAuthentication(), false);
179        $this->assertIdentical($page->getRealm(), false);
180        $this->assertFalse($page->hasFrames());
181        $this->assertIdentical($page->getUrls(), array());
182        $this->assertIdentical($page->getTitle(), false);
183    }
184}
185
186class TestOfPageHeaders extends UnitTestCase {
187
188    function testUrlAccessor() {
189        $headers = &new MockSimpleHttpHeaders();
190
191        $response = &new MockSimpleHttpResponse();
192        $response->setReturnValue('getHeaders', $headers);
193        $response->setReturnValue('getMethod', 'POST');
194        $response->setReturnValue('getUrl', new SimpleUrl('here'));
195        $response->setReturnValue('getRequestData', array('a' => 'A'));
196
197        $page = &new SimplePage($response);
198        $this->assertEqual($page->getMethod(), 'POST');
199        $this->assertEqual($page->getUrl(), new SimpleUrl('here'));
200        $this->assertEqual($page->getRequestData(), array('a' => 'A'));
201    }
202
203    function testTransportError() {
204        $response = &new MockSimpleHttpResponse();
205        $response->setReturnValue('getError', 'Ouch');
206
207        $page = &new SimplePage($response);
208        $this->assertEqual($page->getTransportError(), 'Ouch');
209    }
210
211    function testHeadersAccessor() {
212        $headers = &new MockSimpleHttpHeaders();
213        $headers->setReturnValue('getRaw', 'My: Headers');
214
215        $response = &new MockSimpleHttpResponse();
216        $response->setReturnValue('getHeaders', $headers);
217
218        $page = &new SimplePage($response);
219        $this->assertEqual($page->getHeaders(), 'My: Headers');
220    }
221
222    function testMimeAccessor() {
223        $headers = &new MockSimpleHttpHeaders();
224        $headers->setReturnValue('getMimeType', 'text/html');
225
226        $response = &new MockSimpleHttpResponse();
227        $response->setReturnValue('getHeaders', $headers);
228
229        $page = &new SimplePage($response);
230        $this->assertEqual($page->getMimeType(), 'text/html');
231    }
232
233    function testResponseAccessor() {
234        $headers = &new MockSimpleHttpHeaders();
235        $headers->setReturnValue('getResponseCode', 301);
236
237        $response = &new MockSimpleHttpResponse();
238        $response->setReturnValue('getHeaders', $headers);
239
240        $page = &new SimplePage($response);
241        $this->assertIdentical($page->getResponseCode(), 301);
242    }
243
244    function testAuthenticationAccessors() {
245        $headers = &new MockSimpleHttpHeaders();
246        $headers->setReturnValue('getAuthentication', 'Basic');
247        $headers->setReturnValue('getRealm', 'Secret stuff');
248
249        $response = &new MockSimpleHttpResponse();
250        $response->setReturnValue('getHeaders', $headers);
251
252        $page = &new SimplePage($response);
253        $this->assertEqual($page->getAuthentication(), 'Basic');
254        $this->assertEqual($page->getRealm(), 'Secret stuff');
255    }
256}
257
258class TestOfHtmlPage extends UnitTestCase {
259
260    function testRawAccessor() {
261        $response = &new MockSimpleHttpResponse();
262        $response->setReturnValue('getContent', 'Raw HTML');
263
264        $page = &new SimplePage($response);
265        $this->assertEqual($page->getRaw(), 'Raw HTML');
266    }
267
268    function testTextAccessor() {
269        $response = &new MockSimpleHttpResponse();
270        $response->setReturnValue('getContent', '<b>Some</b> &quot;messy&quot; HTML');
271
272        $page = &new SimplePage($response);
273        $this->assertEqual($page->getText(), 'Some "messy" HTML');
274    }
275
276    function testNoLinks() {
277        $page = &new SimplePage(new MockSimpleHttpResponse());
278        $this->assertIdentical($page->getUrls(), array());
279        $this->assertIdentical($page->getUrlsByLabel('Label'), array());
280    }
281
282    function testAddAbsoluteLink() {
283        $link = &new SimpleAnchorTag(array('href' => 'http://somewhere.com'));
284        $link->addContent('Label');
285        $page = &new SimplePage(new MockSimpleHttpResponse());
286        $page->AcceptTag($link);
287        $this->assertEqual(
288                $page->getUrlsByLabel('Label'),
289                array(new SimpleUrl('http://somewhere.com')));
290    }
291
292    function testAddStrictRelativeLink() {
293        $link = &new SimpleAnchorTag(array('href' => './somewhere.php'));
294        $link->addContent('Label');
295        $response = &new MockSimpleHttpResponse();
296        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
297        $page = &new SimplePage($response);
298        $page->AcceptTag($link);
299        $this->assertEqual(
300                $page->getUrlsByLabel('Label'),
301                array(new SimpleUrl('http://host/somewhere.php')));
302    }
303
304    function testAddBareRelativeLink() {
305        $response = &new MockSimpleHttpResponse();
306        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
307        $page = &new SimplePage($response);
308        $page->AcceptTag(new SimpleAnchorTag(array('href' => 'somewhere.php')));
309        $this->assertIdentical($page->getUrls(), array('http://host/somewhere.php'));
310    }
311
312    function testAddRelativeLinkWithBaseTag() {
313        $link = &new SimpleAnchorTag(array('href' => 'somewhere.php'));
314        $link->addContent('Label');
315        $response = &new MockSimpleHttpResponse();
316        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
317        $page = &new SimplePage($response);
318        $page->AcceptTag($link);       
319        $base = &new SimpleBaseTag(array('href' => 'www.lastcraft.com/stuff/'));
320        $page->AcceptTag($base);
321        $this->assertEqual(
322                $page->getUrlsByLabel('Label'),
323                array(new SimpleUrl('www.lastcraft.com/stuff/somewhere.php')));
324    }
325
326    function testAddAbsoluteLinkWithBaseTag() {
327        $link = &new SimpleAnchorTag(array('href' => 'http://here.com/somewhere.php'));
328        $link->addContent('Label');
329        $response = &new MockSimpleHttpResponse();
330        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
331        $page = &new SimplePage($response);
332        $page->AcceptTag($link);       
333        $base = &new SimpleBaseTag(array('href' => 'www.lastcraft.com/stuff/'));
334        $page->AcceptTag($base);
335        $this->assertEqual(
336                $page->getUrlsByLabel('Label'),
337                array(new SimpleUrl('http://here.com/somewhere.php')));
338    }
339
340    function testLinkIds() {
341        $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
342        $link->addContent('Label');
343
344        $response = &new MockSimpleHttpResponse();
345        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
346
347        $page = &new SimplePage($response);
348        $page->AcceptTag($link);
349
350        $this->assertEqual(
351                $page->getUrlsByLabel('Label'),
352                array(new SimpleUrl('http://host/somewhere.php')));
353        $this->assertFalse($page->getUrlById(0));
354        $this->assertEqual(
355                $page->getUrlById(33),
356                new SimpleUrl('http://host/somewhere.php'));
357    }
358
359    function testFindLinkWithNormalisation() {
360        $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
361        $link->addContent(' <em>Long &amp; thin</em> ');
362
363        $response = &new MockSimpleHttpResponse();
364        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
365
366        $page = &new SimplePage($response);
367        $page->AcceptTag($link);
368
369        $this->assertEqual(
370                $page->getUrlsByLabel('Long & thin'),
371                array(new SimpleUrl('http://host/somewhere.php')));
372    }
373
374    function testFindLinkWithImage() {
375        $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
376        $link->addContent('<img src="pic.jpg" alt="&lt;A picture&gt;">');
377
378        $response = &new MockSimpleHttpResponse();
379        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
380
381        $page = &new SimplePage($response);
382        $page->AcceptTag($link);
383
384        $this->assertEqual(
385                $page->getUrlsByLabel('<A picture>'),
386                array(new SimpleUrl('http://host/somewhere.php')));
387    }
388
389    function testTitleSetting() {
390        $title = &new SimpleTitleTag(array());
391        $title->addContent('Title');
392        $page = &new SimplePage(new MockSimpleHttpResponse());
393        $page->AcceptTag($title);
394        $this->assertEqual($page->getTitle(), 'Title');
395    }
396
397    function testFramesetAbsence() {
398        $url = new SimpleUrl('here');
399        $response = new MockSimpleHttpResponse();
400        $response->setReturnValue('getUrl', $url);
401        $page = &new SimplePage($response);
402        $this->assertFalse($page->hasFrames());
403        $this->assertIdentical($page->getFrameset(), false);
404    }
405
406    function testHasEmptyFrameset() {
407        $page = &new SimplePage(new MockSimpleHttpResponse());
408        $page->acceptFramesetStart(new SimpleTag('frameset', array()));
409        $page->acceptFramesetEnd();
410        $this->assertTrue($page->hasFrames());
411        $this->assertIdentical($page->getFrameset(), array());
412    }
413
414    function testFramesInPage() {
415        $response = &new MockSimpleHttpResponse();
416        $response->setReturnValue('getUrl', new SimpleUrl('http://here'));
417
418        $page = &new SimplePage($response);
419        $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
420        $page->acceptFramesetStart(new SimpleTag('frameset', array()));
421        $page->acceptFrame(new SimpleFrameTag(array('src' => '2.html')));
422        $page->acceptFrame(new SimpleFrameTag(array('src' => '3.html')));
423        $page->acceptFramesetEnd();
424        $page->acceptFrame(new SimpleFrameTag(array('src' => '4.html')));
425
426        $this->assertTrue($page->hasFrames());
427        $this->assertIdentical($page->getFrameset(), array(
428                1 => new SimpleUrl('http://here/2.html'),
429                2 => new SimpleUrl('http://here/3.html')));
430    }
431
432    function testNamedFramesInPage() {
433        $response = &new MockSimpleHttpResponse();
434        $response->setReturnValue('getUrl', new SimpleUrl('http://here'));
435
436        $page = &new SimplePage($response);
437        $page->acceptFramesetStart(new SimpleTag('frameset', array()));
438        $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
439        $page->acceptFrame(new SimpleFrameTag(array('src' => '2.html', 'name' => 'A')));
440        $page->acceptFrame(new SimpleFrameTag(array('src' => '3.html', 'name' => 'B')));
441        $page->acceptFrame(new SimpleFrameTag(array('src' => '4.html')));
442        $page->acceptFramesetEnd();
443
444        $this->assertTrue($page->hasFrames());
445        $this->assertIdentical($page->getFrameset(), array(
446                1 => new SimpleUrl('http://here/1.html'),
447                'A' => new SimpleUrl('http://here/2.html'),
448                'B' => new SimpleUrl('http://here/3.html'),
449                4 => new SimpleUrl('http://here/4.html')));
450    }
451   
452    function testRelativeFramesRespectBaseTag() {
453        $response = &new MockSimpleHttpResponse();
454        $response->setReturnValue('getUrl', new SimpleUrl('http://here.com/'));
455        $page = &new SimplePage($response);
456
457        $base = &new SimpleBaseTag(array('href' => 'https://there.com/stuff/'));
458        $page->AcceptTag($base);
459
460        $page->acceptFramesetStart(new SimpleTag('frameset', array()));
461        $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
462        $page->acceptFramesetEnd();
463        $this->assertIdentical(
464                $page->getFrameset(),
465                array(1 => new SimpleUrl('https://there.com/stuff/1.html')));
466    }
467}
468
469class TestOfFormsCreatedFromEventStream extends UnitTestCase {
470
471    function testFormCanBeSubmitted() {
472        $page = &new SimplePage(new MockSimpleHttpResponse());
473        $page->acceptFormStart(
474                new SimpleFormTag(array('method' => 'GET', 'action' => 'here.php')));
475        $page->AcceptTag(
476                new SimpleSubmitTag(array('type' => 'submit', 'name' => 's')));
477        $page->acceptFormEnd();
478        $form = &$page->getFormBySubmit(new SimpleByLabel('Submit'));
479        $this->assertEqual(
480                $form->submitButton(new SimpleByLabel('Submit')),
481                new SimpleGetEncoding(array('s' => 'Submit')));
482    }
483
484    function testInputFieldCanBeReadBack() {
485        $page = &new SimplePage(new MockSimpleHttpResponse());
486        $page->acceptFormStart(
487                new SimpleFormTag(array("method" => "GET", "action" => "here.php")));
488        $page->AcceptTag(
489                new SimpleTextTag(array("type" => "text", "name" => "a", "value" => "A")));
490        $page->AcceptTag(
491                new SimpleSubmitTag(array("type" => "submit", "name" => "s")));
492        $page->acceptFormEnd();
493        $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
494    }
495
496    function testInputFieldCanBeReadBackByLabel() {
497        $label = &new SimpleLabelTag(array());
498        $page = &new SimplePage(new MockSimpleHttpResponse());
499        $page->acceptFormStart(
500                new SimpleFormTag(array("method" => "GET", "action" => "here.php")));
501        $page->acceptLabelStart($label);
502        $label->addContent('l');
503        $page->AcceptTag(
504                new SimpleTextTag(array("type" => "text", "name" => "a", "value" => "A")));
505        $page->acceptLabelEnd();
506        $page->AcceptTag(
507                new SimpleSubmitTag(array("type" => "submit", "name" => "s")));
508        $page->acceptFormEnd();
509        $this->assertEqual($page->getField(new SimpleByLabel('l')), 'A');
510    }
511}
512
513class TestOfPageScraping extends UnitTestCase {
514
515    function &parse($response) {
516        $builder = &new SimplePageBuilder();
517        $page = &$builder->parse($response);
518        return $page;
519    }
520
521    function testEmptyPage() {
522        $page = &new SimplePage(new MockSimpleHttpResponse());
523        $this->assertIdentical($page->getUrls(), array());
524        $this->assertIdentical($page->getTitle(), false);
525    }
526
527    function testUninterestingPage() {
528        $response = &new MockSimpleHttpResponse();
529        $response->setReturnValue('getContent', '<html><body><p>Stuff</p></body></html>');
530        $page = &$this->parse($response);
531        $this->assertIdentical($page->getUrls(), array());
532    }
533
534    function testLinksPage() {
535        $raw = '<html>';
536        $raw .= '<a href="there.html">There</a>';
537        $raw .= '<a href="http://there.com/that.html" id="0">That page</a>';
538        $raw .= '</html>';
539        $response = &new MockSimpleHttpResponse();
540        $response->setReturnValue('getContent', $raw);
541        $response->setReturnValue('getUrl', new SimpleUrl('http://www.here.com/a/index.html'));
542
543        $page = &$this->parse($response);
544        $this->assertIdentical(
545                $page->getUrls(),
546                array('http://www.here.com/a/there.html', 'http://there.com/that.html'));
547        $this->assertIdentical(
548                $page->getUrlsByLabel('There'),
549                array(new SimpleUrl('http://www.here.com/a/there.html')));
550        $this->assertEqual(
551                $page->getUrlById('0'),
552                new SimpleUrl('http://there.com/that.html'));
553    }
554
555    function testTitle() {
556        $response = &new MockSimpleHttpResponse();
557        $response->setReturnValue('getContent', '<html><head><title>Me</title></head></html>');
558        $page = &$this->parse($response);
559        $this->assertEqual($page->getTitle(), 'Me');
560    }
561
562    function testNastyTitle() {
563        $response = &new MockSimpleHttpResponse();
564        $response->setReturnValue(
565                'getContent',
566                '<html><head><Title> <b>Me&amp;Me </TITLE></b></head></html>');
567        $page = &$this->parse($response);
568        $this->assertEqual($page->getTitle(), "Me&Me");
569    }
570
571    function testCompleteForm() {
572        $response = &new MockSimpleHttpResponse();
573        $response->setReturnValue('getContent',
574                '<html><head><form>' .
575                '<input type="text" name="here" value="Hello">' .
576                '</form></head></html>');
577        $page = &$this->parse($response);
578        $this->assertEqual($page->getField(new SimpleByName('here')), "Hello");
579    }
580
581    function testUnclosedForm() {
582        $response = &new MockSimpleHttpResponse();
583        $response->setReturnValue('getContent',
584                '<html><head><form>' .
585                '<input type="text" name="here" value="Hello">' .
586                '</head></html>');
587        $page = &$this->parse($response);
588        $this->assertEqual($page->getField(new SimpleByName('here')), "Hello");
589    }
590
591    function testEmptyFrameset() {
592        $response = &new MockSimpleHttpResponse();
593        $response->setReturnValue(
594                'getContent',
595                '<html><frameset></frameset></html>');
596        $page = &$this->parse($response);
597        $this->assertTrue($page->hasFrames());
598        $this->assertIdentical($page->getFrameset(), array());
599    }
600
601    function testSingleFrame() {
602        $response = &new MockSimpleHttpResponse();
603        $response->setReturnValue(
604                'getContent',
605                '<html><frameset><frame src="a.html"></frameset></html>');
606        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
607
608        $page = &$this->parse($response);
609        $this->assertTrue($page->hasFrames());
610        $this->assertIdentical(
611                $page->getFrameset(),
612                array(1 => new SimpleUrl('http://host/a.html')));
613    }
614
615    function testSingleFrameInNestedFrameset() {
616        $response = &new MockSimpleHttpResponse();
617        $response->setReturnValue('getContent',
618                '<html><frameset><frameset>' .
619                '<frame src="a.html">' .
620                '</frameset></frameset></html>');
621        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
622
623        $page = &$this->parse($response);
624        $this->assertTrue($page->hasFrames());
625        $this->assertIdentical(
626                $page->getFrameset(),
627                array(1 => new SimpleUrl('http://host/a.html')));
628    }
629
630    function testFrameWithNoSource() {
631        $response = &new MockSimpleHttpResponse();
632        $response->setReturnValue(
633                'getContent',
634                '<html><frameset><frame></frameset></html>');
635        $page = &$this->parse($response);
636        $this->assertTrue($page->hasFrames());
637        $this->assertIdentical($page->getFrameset(), array());
638    }
639
640    function testFramesCollectedWithNestedFramesetTags() {
641        $response = &new MockSimpleHttpResponse();
642        $response->setReturnValue('getContent',
643                '<html><frameset>' .
644                '<frame src="a.html">' .
645                '<frameset><frame src="b.html"></frameset>' .
646                '<frame src="c.html">' .
647                '</frameset></html>');
648        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
649
650        $page = &$this->parse($response);
651        $this->assertTrue($page->hasFrames());
652        $this->assertIdentical($page->getFrameset(), array(
653                1 => new SimpleUrl('http://host/a.html'),
654                2 => new SimpleUrl('http://host/b.html'),
655                3 => new SimpleUrl('http://host/c.html')));
656    }
657
658    function testNamedFrames() {
659        $response = &new MockSimpleHttpResponse();
660        $response->setReturnValue('getContent',
661                '<html><frameset>' .
662                '<frame src="a.html">' .
663                '<frame name="_one" src="b.html">' .
664                '<frame src="c.html">' .
665                '<frame src="d.html" name="_two">' .
666                '</frameset></html>');
667        $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
668
669        $page = &$this->parse($response);
670        $this->assertTrue($page->hasFrames());
671        $this->assertIdentical($page->getFrameset(), array(
672                1 => new SimpleUrl('http://host/a.html'),
673                '_one' => new SimpleUrl('http://host/b.html'),
674                3 => new SimpleUrl('http://host/c.html'),
675                '_two' => new SimpleUrl('http://host/d.html')));
676    }
677
678    function testFindFormByLabel() {
679        $response = &new MockSimpleHttpResponse();
680        $response->setReturnValue(
681                'getContent',
682                '<html><head><form><input type="submit"></form></head></html>');
683        $page = &$this->parse($response);
684        $this->assertNull($page->getFormBySubmit(new SimpleByLabel('submit')));
685        $this->assertNull($page->getFormBySubmit(new SimpleByName('submit')));
686        $this->assertIsA(
687                $page->getFormBySubmit(new SimpleByLabel('Submit')),
688                'SimpleForm');
689    }
690
691    function testConfirmSubmitAttributesAreCaseSensitive() {
692        $response = &new MockSimpleHttpResponse();
693        $response->setReturnValue(
694                'getContent',
695                '<html><head><FORM><INPUT TYPE="SUBMIT" NAME="S" VALUE="S"></FORM></head></html>');
696        $page = &$this->parse($response);
697        $this->assertIsA(
698                $page->getFormBySubmit(new SimpleByName('S')),
699                'SimpleForm');
700        $this->assertIsA(
701                $page->getFormBySubmit(new SimpleByLabel('S')),
702                'SimpleForm');
703    }
704
705    function testFindFormByImage() {
706        $response = &new MockSimpleHttpResponse();
707        $response->setReturnValue('getContent',
708                '<html><head><form>' .
709                '<input type="image" id=100 alt="Label" name="me">' .
710                '</form></head></html>');
711        $page = &$this->parse($response);
712        $this->assertIsA(
713                $page->getFormByImage(new SimpleByLabel('Label')),
714                'SimpleForm');
715        $this->assertIsA(
716                $page->getFormByImage(new SimpleByName('me')),
717                'SimpleForm');
718        $this->assertIsA(
719                $page->getFormByImage(new SimpleById(100)),
720                'SimpleForm');
721    }
722
723    function testFindFormByButtonTag() {
724        $response = &new MockSimpleHttpResponse();
725        $response->setReturnValue('getContent',
726                '<html><head><form>' .
727                '<button type="submit" name="b" value="B">BBB</button>' .
728                '</form></head></html>');
729        $page = &$this->parse($response);
730        $this->assertNull($page->getFormBySubmit(new SimpleByLabel('b')));
731        $this->assertNull($page->getFormBySubmit(new SimpleByLabel('B')));
732        $this->assertIsA(
733                $page->getFormBySubmit(new SimpleByName('b')),
734                'SimpleForm');
735        $this->assertIsA(
736                $page->getFormBySubmit(new SimpleByLabel('BBB')),
737                'SimpleForm');
738    }
739
740    function testFindFormById() {
741        $response = &new MockSimpleHttpResponse();
742        $response->setReturnValue(
743                'getContent',
744                '<html><head><form id="55"><input type="submit"></form></head></html>');
745        $page = &$this->parse($response);
746        $this->assertNull($page->getFormById(54));
747        $this->assertIsA($page->getFormById(55), 'SimpleForm');
748    }
749
750    function testReadingTextField() {
751        $response = &new MockSimpleHttpResponse();
752        $response->setReturnValue('getContent',
753                '<html><head><form>' .
754                '<input type="text" name="a">' .
755                '<input type="text" name="b" value="bbb" id=3>' .
756                '</form></head></html>');
757        $page = &$this->parse($response);
758        $this->assertNull($page->getField(new SimpleByName('missing')));
759        $this->assertIdentical($page->getField(new SimpleByName('a')), '');
760        $this->assertIdentical($page->getField(new SimpleByName('b')), 'bbb');
761    }
762
763    function testReadingTextFieldIsCaseInsensitive() {
764        $response = &new MockSimpleHttpResponse();
765        $response->setReturnValue('getContent',
766                '<html><head><FORM>' .
767                '<INPUT TYPE="TEXT" NAME="a">' .
768                '<INPUT TYPE="TEXT" NAME="b" VALUE="bbb" id=3>' .
769                '</FORM></head></html>');
770        $page = &$this->parse($response);
771        $this->assertNull($page->getField(new SimpleByName('missing')));
772        $this->assertIdentical($page->getField(new SimpleByName('a')), '');
773        $this->assertIdentical($page->getField(new SimpleByName('b')), 'bbb');
774    }
775
776    function testSettingTextField() {
777        $response = &new MockSimpleHttpResponse();
778        $response->setReturnValue('getContent',
779                '<html><head><form>' .
780                '<input type="text" name="a">' .
781                '<input type="text" name="b" id=3>' .
782                '<input type="submit">' .
783                '</form></head></html>');
784        $page = &$this->parse($response);
785        $this->assertTrue($page->setField(new SimpleByName('a'), 'aaa'));
786        $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
787        $this->assertTrue($page->setField(new SimpleById(3), 'bbb'));
788        $this->assertEqual($page->getField(new SimpleBYId(3)), 'bbb');
789        $this->assertFalse($page->setField(new SimpleByName('z'), 'zzz'));
790        $this->assertNull($page->getField(new SimpleByName('z')));
791    }
792
793    function testSettingTextFieldByEnclosingLabel() {
794        $response = &new MockSimpleHttpResponse();
795        $response->setReturnValue('getContent',
796                '<html><head><form>' .
797                '<label>Stuff' .
798                '<input type="text" name="a" value="A">' .
799                '</label>' .
800                '</form></head></html>');
801        $page = &$this->parse($response);
802        $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
803        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
804        $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'aaa'));
805        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'aaa');
806    }
807
808    function testGettingTextFieldByEnclosingLabelWithConflictingOtherFields() {
809        $response = &new MockSimpleHttpResponse();
810        $response->setReturnValue('getContent',
811                '<html><head><form>' .
812                '<label>Stuff' .
813                '<input type="text" name="a" value="A">' .
814                '</label>' .
815                '<input type="text" name="b" value="B">' .
816                '</form></head></html>');
817        $page = &$this->parse($response);
818        $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
819        $this->assertEqual($page->getField(new SimpleByName('b')), 'B');
820        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
821    }
822
823    function testSettingTextFieldByExternalLabel() {
824        $response = &new MockSimpleHttpResponse();
825        $response->setReturnValue('getContent',
826                '<html><head><form>' .
827                '<label for="aaa">Stuff</label>' .
828                '<input id="aaa" type="text" name="a" value="A">' .
829                '</form></head></html>');
830        $page = &$this->parse($response);
831        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
832        $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'aaa'));
833        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'aaa');
834    }
835
836    function testReadingTextArea() {
837        $response = &new MockSimpleHttpResponse();
838        $response->setReturnValue('getContent',
839                '<html><head><form>' .
840                '<textarea name="a">aaa</textarea>' .
841                '<input type="submit">' .
842                '</form></head></html>');
843        $page = &$this->parse($response);
844        $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
845    }
846
847    function testSettingTextArea() {
848        $response = &new MockSimpleHttpResponse();
849        $response->setReturnValue('getContent',
850                '<html><head><form>' .
851                '<textarea name="a">aaa</textarea>' .
852                '<input type="submit">' .
853                '</form></head></html>');
854        $page = &$this->parse($response);
855        $this->assertTrue($page->setField(new SimpleByName('a'), 'AAA'));
856        $this->assertEqual($page->getField(new SimpleByName('a')), 'AAA');
857    }
858
859    function testSettingSelectionField() {
860        $response = &new MockSimpleHttpResponse();
861        $response->setReturnValue('getContent',
862                '<html><head><form>' .
863                '<select name="a">' .
864                '<option>aaa</option>' .
865                '<option selected>bbb</option>' .
866                '</select>' .
867                '<input type="submit">' .
868                '</form></head></html>');
869        $page = &$this->parse($response);
870        $this->assertEqual($page->getField(new SimpleByName('a')), 'bbb');
871        $this->assertFalse($page->setField(new SimpleByName('a'), 'ccc'));
872        $this->assertTrue($page->setField(new SimpleByName('a'), 'aaa'));
873        $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
874    }
875
876    function testSettingSelectionFieldByEnclosingLabel() {
877        $response = &new MockSimpleHttpResponse();
878        $response->setReturnValue('getContent',
879                '<html><head><form>' .
880                '<label>Stuff' .
881                '<select name="a"><option selected>A</option><option>B</option></select>' .
882                '</label>' .
883                '</form></head></html>');
884        $page = &$this->parse($response);
885        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
886        $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'B'));
887        $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'B');
888    }
889
890    function testSettingRadioButtonByEnclosingLabel() {
891        $response = &new MockSimpleHttpResponse();
892        $response->setReturnValue('getContent',
893                '<html><head><form>' .
894                '<label>A<input type="radio" name="r" value="a" checked></label>' .
895                '<label>B<input type="radio" name="r" value="b"></label>' .
896                '</form></head></html>');
897        $page = &$this->parse($response);
898        $this->assertEqual($page->getField(new SimpleByLabel('A')), 'a');
899        $this->assertTrue($page->setField(new SimpleBylabel('B'), 'b'));
900        $this->assertEqual($page->getField(new SimpleByLabel('B')), 'b');
901    }
902}
903?>
Note: See TracBrowser for help on using the repository browser.