source: trunk/server/www/vendors/simpletest/test/frames_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: 19.7 KB
Line 
1<?php
2// $Id: frames_test.php 1555 2007-07-14 02:04:34Z lastcraft $
3require_once(dirname(__FILE__) . '/../autorun.php');
4require_once(dirname(__FILE__) . '/../tag.php');
5require_once(dirname(__FILE__) . '/../page.php');
6require_once(dirname(__FILE__) . '/../frames.php');
7Mock::generate('SimplePage');
8Mock::generate('SimpleForm');
9
10class TestOfFrameset extends UnitTestCase {
11
12    function testTitleReadFromFramesetPage() {
13        $page = &new MockSimplePage();
14        $page->setReturnValue('getTitle', 'This page');
15        $frameset = &new SimpleFrameset($page);
16        $this->assertEqual($frameset->getTitle(), 'This page');
17    }
18
19    function TestHeadersReadFromFramesetByDefault() {
20        $page = &new MockSimplePage();
21        $page->setReturnValue('getHeaders', 'Header: content');
22        $page->setReturnValue('getMimeType', 'text/xml');
23        $page->setReturnValue('getResponseCode', 401);
24        $page->setReturnValue('getTransportError', 'Could not parse headers');
25        $page->setReturnValue('getAuthentication', 'Basic');
26        $page->setReturnValue('getRealm', 'Safe place');
27
28        $frameset = &new SimpleFrameset($page);
29
30        $this->assertIdentical($frameset->getHeaders(), 'Header: content');
31        $this->assertIdentical($frameset->getMimeType(), 'text/xml');
32        $this->assertIdentical($frameset->getResponseCode(), 401);
33        $this->assertIdentical($frameset->getTransportError(), 'Could not parse headers');
34        $this->assertIdentical($frameset->getAuthentication(), 'Basic');
35        $this->assertIdentical($frameset->getRealm(), 'Safe place');
36    }
37
38    function testEmptyFramesetHasNoContent() {
39        $page = &new MockSimplePage();
40        $page->setReturnValue('getRaw', 'This content');
41        $frameset = &new SimpleFrameset($page);
42        $this->assertEqual($frameset->getRaw(), '');
43    }
44
45    function testRawContentIsFromOnlyFrame() {
46        $page = &new MockSimplePage();
47        $page->expectNever('getRaw');
48
49        $frame = &new MockSimplePage();
50        $frame->setReturnValue('getRaw', 'Stuff');
51
52        $frameset = &new SimpleFrameset($page);
53        $frameset->addFrame($frame);
54        $this->assertEqual($frameset->getRaw(), 'Stuff');
55    }
56
57    function testRawContentIsFromAllFrames() {
58        $page = &new MockSimplePage();
59        $page->expectNever('getRaw');
60
61        $frame1 = &new MockSimplePage();
62        $frame1->setReturnValue('getRaw', 'Stuff1');
63
64        $frame2 = &new MockSimplePage();
65        $frame2->setReturnValue('getRaw', 'Stuff2');
66
67        $frameset = &new SimpleFrameset($page);
68        $frameset->addFrame($frame1);
69        $frameset->addFrame($frame2);
70        $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
71    }
72
73    function testTextContentIsFromOnlyFrame() {
74        $page = &new MockSimplePage();
75        $page->expectNever('getText');
76
77        $frame = &new MockSimplePage();
78        $frame->setReturnValue('getText', 'Stuff');
79
80        $frameset = &new SimpleFrameset($page);
81        $frameset->addFrame($frame);
82        $this->assertEqual($frameset->getText(), 'Stuff');
83    }
84
85    function testTextContentIsFromAllFrames() {
86        $page = &new MockSimplePage();
87        $page->expectNever('getText');
88
89        $frame1 = &new MockSimplePage();
90        $frame1->setReturnValue('getText', 'Stuff1');
91
92        $frame2 = &new MockSimplePage();
93        $frame2->setReturnValue('getText', 'Stuff2');
94
95        $frameset = &new SimpleFrameset($page);
96        $frameset->addFrame($frame1);
97        $frameset->addFrame($frame2);
98        $this->assertEqual($frameset->getText(), 'Stuff1 Stuff2');
99    }
100
101    function testFieldFoundIsFirstInFramelist() {
102        $frame1 = &new MockSimplePage();
103        $frame1->setReturnValue('getField', null);
104        $frame1->expectOnce('getField', array(new SimpleByName('a')));
105
106        $frame2 = &new MockSimplePage();
107        $frame2->setReturnValue('getField', 'A');
108        $frame2->expectOnce('getField', array(new SimpleByName('a')));
109
110        $frame3 = &new MockSimplePage();
111        $frame3->expectNever('getField');
112
113        $page = &new MockSimplePage();
114        $frameset = &new SimpleFrameset($page);
115        $frameset->addFrame($frame1);
116        $frameset->addFrame($frame2);
117        $frameset->addFrame($frame3);
118        $this->assertIdentical($frameset->getField(new SimpleByName('a')), 'A');
119    }
120
121    function testFrameReplacementByIndex() {
122        $page = &new MockSimplePage();
123        $page->expectNever('getRaw');
124
125        $frame1 = &new MockSimplePage();
126        $frame1->setReturnValue('getRaw', 'Stuff1');
127
128        $frame2 = &new MockSimplePage();
129        $frame2->setReturnValue('getRaw', 'Stuff2');
130
131        $frameset = &new SimpleFrameset($page);
132        $frameset->addFrame($frame1);
133        $frameset->setFrame(array(1), $frame2);
134        $this->assertEqual($frameset->getRaw(), 'Stuff2');
135    }
136
137    function testFrameReplacementByName() {
138        $page = &new MockSimplePage();
139        $page->expectNever('getRaw');
140
141        $frame1 = &new MockSimplePage();
142        $frame1->setReturnValue('getRaw', 'Stuff1');
143
144        $frame2 = &new MockSimplePage();
145        $frame2->setReturnValue('getRaw', 'Stuff2');
146
147        $frameset = &new SimpleFrameset($page);
148        $frameset->addFrame($frame1, 'a');
149        $frameset->setFrame(array('a'), $frame2);
150        $this->assertEqual($frameset->getRaw(), 'Stuff2');
151    }
152}
153
154class TestOfFrameNavigation extends UnitTestCase {
155
156    function testStartsWithoutFrameFocus() {
157        $page = &new MockSimplePage();
158        $frameset = &new SimpleFrameset($page);
159        $frameset->addFrame($frame);
160        $this->assertFalse($frameset->getFrameFocus());
161    }
162
163    function testCanFocusOnSingleFrame() {
164        $page = &new MockSimplePage();
165        $page->expectNever('getRaw');
166
167        $frame = &new MockSimplePage();
168        $frame->setReturnValue('getFrameFocus', array());
169        $frame->setReturnValue('getRaw', 'Stuff');
170
171        $frameset = &new SimpleFrameset($page);
172        $frameset->addFrame($frame);
173
174        $this->assertFalse($frameset->setFrameFocusByIndex(0));
175        $this->assertTrue($frameset->setFrameFocusByIndex(1));
176        $this->assertEqual($frameset->getRaw(), 'Stuff');
177        $this->assertFalse($frameset->setFrameFocusByIndex(2));
178        $this->assertIdentical($frameset->getFrameFocus(), array(1));
179    }
180
181    function testContentComesFromFrameInFocus() {
182        $page = &new MockSimplePage();
183
184        $frame1 = &new MockSimplePage();
185        $frame1->setReturnValue('getRaw', 'Stuff1');
186        $frame1->setReturnValue('getFrameFocus', array());
187
188        $frame2 = &new MockSimplePage();
189        $frame2->setReturnValue('getRaw', 'Stuff2');
190        $frame2->setReturnValue('getFrameFocus', array());
191
192        $frameset = &new SimpleFrameset($page);
193        $frameset->addFrame($frame1);
194        $frameset->addFrame($frame2);
195
196        $this->assertTrue($frameset->setFrameFocusByIndex(1));
197        $this->assertEqual($frameset->getFrameFocus(), array(1));
198        $this->assertEqual($frameset->getRaw(), 'Stuff1');
199
200        $this->assertTrue($frameset->setFrameFocusByIndex(2));
201        $this->assertEqual($frameset->getFrameFocus(), array(2));
202        $this->assertEqual($frameset->getRaw(), 'Stuff2');
203
204        $this->assertFalse($frameset->setFrameFocusByIndex(3));
205        $this->assertEqual($frameset->getFrameFocus(), array(2));
206
207        $frameset->clearFrameFocus();
208        $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
209    }
210
211    function testCanFocusByName() {
212        $page = &new MockSimplePage();
213
214        $frame1 = &new MockSimplePage();
215        $frame1->setReturnValue('getRaw', 'Stuff1');
216        $frame1->setReturnValue('getFrameFocus', array());
217
218        $frame2 = &new MockSimplePage();
219        $frame2->setReturnValue('getRaw', 'Stuff2');
220        $frame2->setReturnValue('getFrameFocus', array());
221
222        $frameset = &new SimpleFrameset($page);
223        $frameset->addFrame($frame1, 'A');
224        $frameset->addFrame($frame2, 'B');
225
226        $this->assertTrue($frameset->setFrameFocus('A'));
227        $this->assertEqual($frameset->getFrameFocus(), array('A'));
228        $this->assertEqual($frameset->getRaw(), 'Stuff1');
229
230        $this->assertTrue($frameset->setFrameFocusByIndex(2));
231        $this->assertEqual($frameset->getFrameFocus(), array('B'));
232        $this->assertEqual($frameset->getRaw(), 'Stuff2');
233
234        $this->assertFalse($frameset->setFrameFocus('z'));
235
236        $frameset->clearFrameFocus();
237        $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
238    }
239}
240
241class TestOfFramesetPageInterface extends UnitTestCase {
242    var $_page_interface;
243    var $_frameset_interface;
244
245    function TestOfFramesetPageInterface() {
246        $this->UnitTestCase();
247        $this->_page_interface = $this->_getPageMethods();
248        $this->_frameset_interface = $this->_getFramesetMethods();
249    }
250
251    function assertListInAnyOrder($list, $expected) {
252        sort($list);
253        sort($expected);
254        $this->assertEqual($list, $expected);
255    }
256
257    function _getPageMethods() {
258        $methods = array();
259        foreach (get_class_methods('SimplePage') as $method) {
260            if (strtolower($method) == strtolower('SimplePage')) {
261                continue;
262            }
263            if (strtolower($method) == strtolower('getFrameset')) {
264                continue;
265            }
266            if (strncmp($method, '_', 1) == 0) {
267                continue;
268            }
269            if (strncmp($method, 'accept', 6) == 0) {
270                continue;
271            }
272            $methods[] = $method;
273        }
274        return $methods;
275    }
276
277    function _getFramesetMethods() {
278        $methods = array();
279        foreach (get_class_methods('SimpleFrameset') as $method) {
280            if (strtolower($method) == strtolower('SimpleFrameset')) {
281                continue;
282            }
283            if (strncmp($method, '_', 1) == 0) {
284                continue;
285            }
286            if (strncmp($method, 'add', 3) == 0) {
287                continue;
288            }
289            $methods[] = $method;
290        }
291        return $methods;
292    }
293
294    function testFramsetHasPageInterface() {
295        $difference = array();
296        foreach ($this->_page_interface as $method) {
297            if (! in_array($method, $this->_frameset_interface)) {
298                $this->fail("No [$method] in Frameset class");
299                return;
300            }
301        }
302        $this->pass('Frameset covers Page interface');
303    }
304
305    function testHeadersReadFromFrameIfInFocus() {
306        $frame = &new MockSimplePage();
307        $frame->setReturnValue('getUrl', new SimpleUrl('http://localhost/stuff'));
308
309        $frame->setReturnValue('getRequest', 'POST stuff');
310        $frame->setReturnValue('getMethod', 'POST');
311        $frame->setReturnValue('getRequestData', array('a' => 'A'));
312        $frame->setReturnValue('getHeaders', 'Header: content');
313        $frame->setReturnValue('getMimeType', 'text/xml');
314        $frame->setReturnValue('getResponseCode', 401);
315        $frame->setReturnValue('getTransportError', 'Could not parse headers');
316        $frame->setReturnValue('getAuthentication', 'Basic');
317        $frame->setReturnValue('getRealm', 'Safe place');
318
319        $frameset = &new SimpleFrameset(new MockSimplePage());
320        $frameset->addFrame($frame);
321        $frameset->setFrameFocusByIndex(1);
322
323        $url = new SimpleUrl('http://localhost/stuff');
324        $url->setTarget(1);
325        $this->assertIdentical($frameset->getUrl(), $url);
326
327        $this->assertIdentical($frameset->getRequest(), 'POST stuff');
328        $this->assertIdentical($frameset->getMethod(), 'POST');
329        $this->assertIdentical($frameset->getRequestData(), array('a' => 'A'));
330        $this->assertIdentical($frameset->getHeaders(), 'Header: content');
331        $this->assertIdentical($frameset->getMimeType(), 'text/xml');
332        $this->assertIdentical($frameset->getResponseCode(), 401);
333        $this->assertIdentical($frameset->getTransportError(), 'Could not parse headers');
334        $this->assertIdentical($frameset->getAuthentication(), 'Basic');
335        $this->assertIdentical($frameset->getRealm(), 'Safe place');
336    }
337
338    function testUrlsComeFromBothFrames() {
339        $page = &new MockSimplePage();
340        $page->expectNever('getUrls');
341
342        $frame1 = &new MockSimplePage();
343        $frame1->setReturnValue(
344                'getUrls',
345                array('http://www.lastcraft.com/', 'http://myserver/'));
346
347        $frame2 = &new MockSimplePage();
348        $frame2->setReturnValue(
349                'getUrls',
350                array('http://www.lastcraft.com/', 'http://test/'));
351
352        $frameset = &new SimpleFrameset($page);
353        $frameset->addFrame($frame1);
354        $frameset->addFrame($frame2);
355        $this->assertListInAnyOrder(
356                $frameset->getUrls(),
357                array('http://www.lastcraft.com/', 'http://myserver/', 'http://test/'));
358    }
359
360    function testLabelledUrlsComeFromBothFrames() {
361        $frame1 = &new MockSimplePage();
362        $frame1->setReturnValue(
363                'getUrlsByLabel',
364                array(new SimpleUrl('goodbye.php')),
365                array('a'));
366
367        $frame2 = &new MockSimplePage();
368        $frame2->setReturnValue(
369                'getUrlsByLabel',
370                array(new SimpleUrl('hello.php')),
371                array('a'));
372
373        $frameset = &new SimpleFrameset(new MockSimplePage());
374        $frameset->addFrame($frame1);
375        $frameset->addFrame($frame2, 'Two');
376
377        $expected1 = new SimpleUrl('goodbye.php');
378        $expected1->setTarget(1);
379        $expected2 = new SimpleUrl('hello.php');
380        $expected2->setTarget('Two');
381        $this->assertEqual(
382                $frameset->getUrlsByLabel('a'),
383                array($expected1, $expected2));
384    }
385
386    function testUrlByIdComesFromFirstFrameToRespond() {
387        $frame1 = &new MockSimplePage();
388        $frame1->setReturnValue('getUrlById', new SimpleUrl('four.php'), array(4));
389        $frame1->setReturnValue('getUrlById', false, array(5));
390
391        $frame2 = &new MockSimplePage();
392        $frame2->setReturnValue('getUrlById', false, array(4));
393        $frame2->setReturnValue('getUrlById', new SimpleUrl('five.php'), array(5));
394
395        $frameset = &new SimpleFrameset(new MockSimplePage());
396        $frameset->addFrame($frame1);
397        $frameset->addFrame($frame2);
398
399        $four = new SimpleUrl('four.php');
400        $four->setTarget(1);
401        $this->assertEqual($frameset->getUrlById(4), $four);
402        $five = new SimpleUrl('five.php');
403        $five->setTarget(2);
404        $this->assertEqual($frameset->getUrlById(5), $five);
405    }
406
407    function testReadUrlsFromFrameInFocus() {
408        $frame1 = &new MockSimplePage();
409        $frame1->setReturnValue('getUrls', array('a'));
410        $frame1->setReturnValue('getUrlsByLabel', array(new SimpleUrl('l')));
411        $frame1->setReturnValue('getUrlById', new SimpleUrl('i'));
412
413        $frame2 = &new MockSimplePage();
414        $frame2->expectNever('getUrls');
415        $frame2->expectNever('getUrlsByLabel');
416        $frame2->expectNever('getUrlById');
417
418        $frameset = &new SimpleFrameset(new MockSimplePage());
419        $frameset->addFrame($frame1, 'A');
420        $frameset->addFrame($frame2, 'B');
421        $frameset->setFrameFocus('A');
422
423        $this->assertIdentical($frameset->getUrls(), array('a'));
424        $expected = new SimpleUrl('l');
425        $expected->setTarget('A');
426        $this->assertIdentical($frameset->getUrlsByLabel('label'), array($expected));
427        $expected = new SimpleUrl('i');
428        $expected->setTarget('A');
429        $this->assertIdentical($frameset->getUrlById(99), $expected);
430    }
431
432    function testReadFrameTaggedUrlsFromFrameInFocus() {
433        $frame = &new MockSimplePage();
434
435        $by_label = new SimpleUrl('l');
436        $by_label->setTarget('L');
437        $frame->setReturnValue('getUrlsByLabel', array($by_label));
438
439        $by_id = new SimpleUrl('i');
440        $by_id->setTarget('I');
441        $frame->setReturnValue('getUrlById', $by_id);
442
443        $frameset = &new SimpleFrameset(new MockSimplePage());
444        $frameset->addFrame($frame, 'A');
445        $frameset->setFrameFocus('A');
446
447        $this->assertIdentical($frameset->getUrlsByLabel('label'), array($by_label));
448        $this->assertIdentical($frameset->getUrlById(99), $by_id);
449    }
450
451    function testFindingFormsById() {
452        $frame = &new MockSimplePage();
453        $form = &new MockSimpleForm();
454        $frame->setReturnReference('getFormById', $form, array('a'));
455
456        $frameset = &new SimpleFrameset(new MockSimplePage());
457        $frameset->addFrame(new MockSimplePage(), 'A');
458        $frameset->addFrame($frame, 'B');
459        $this->assertReference($frameset->getFormById('a'), $form);
460
461        $frameset->setFrameFocus('A');
462        $this->assertNull($frameset->getFormById('a'));
463
464        $frameset->setFrameFocus('B');
465        $this->assertReference($frameset->getFormById('a'), $form);
466    }
467
468    function testFindingFormsBySubmit() {
469        $frame = &new MockSimplePage();
470        $form = &new MockSimpleForm();
471        $frame->setReturnReference(
472                'getFormBySubmit',
473                $form,
474                array(new SimpleByLabel('a')));
475
476        $frameset = &new SimpleFrameset(new MockSimplePage());
477        $frameset->addFrame(new MockSimplePage(), 'A');
478        $frameset->addFrame($frame, 'B');
479        $this->assertReference($frameset->getFormBySubmit(new SimpleByLabel('a')), $form);
480
481        $frameset->setFrameFocus('A');
482        $this->assertNull($frameset->getFormBySubmit(new SimpleByLabel('a')));
483
484        $frameset->setFrameFocus('B');
485        $this->assertReference($frameset->getFormBySubmit(new SimpleByLabel('a')), $form);
486    }
487
488    function testFindingFormsByImage() {
489        $frame = &new MockSimplePage();
490        $form = &new MockSimpleForm();
491        $frame->setReturnReference(
492                'getFormByImage',
493                $form,
494                array(new SimpleByLabel('a')));
495
496        $frameset = &new SimpleFrameset(new MockSimplePage());
497        $frameset->addFrame(new MockSimplePage(), 'A');
498        $frameset->addFrame($frame, 'B');
499        $this->assertReference($frameset->getFormByImage(new SimpleByLabel('a')), $form);
500
501        $frameset->setFrameFocus('A');
502        $this->assertNull($frameset->getFormByImage(new SimpleByLabel('a')));
503
504        $frameset->setFrameFocus('B');
505        $this->assertReference($frameset->getFormByImage(new SimpleByLabel('a')), $form);
506    }
507
508    function testSettingAllFrameFieldsWhenNoFrameFocus() {
509        $frame1 = &new MockSimplePage();
510        $frame1->expectOnce('setField', array(new SimpleById(22), 'A'));
511
512        $frame2 = &new MockSimplePage();
513        $frame2->expectOnce('setField', array(new SimpleById(22), 'A'));
514
515        $frameset = &new SimpleFrameset(new MockSimplePage());
516        $frameset->addFrame($frame1, 'A');
517        $frameset->addFrame($frame2, 'B');
518        $frameset->setField(new SimpleById(22), 'A');
519    }
520
521    function testOnlySettingFieldFromFocusedFrame() {
522        $frame1 = &new MockSimplePage();
523        $frame1->expectOnce('setField', array(new SimpleByLabelOrName('a'), 'A'));
524
525        $frame2 = &new MockSimplePage();
526        $frame2->expectNever('setField');
527
528        $frameset = &new SimpleFrameset(new MockSimplePage());
529        $frameset->addFrame($frame1, 'A');
530        $frameset->addFrame($frame2, 'B');
531        $frameset->setFrameFocus('A');
532        $frameset->setField(new SimpleByLabelOrName('a'), 'A');
533    }
534
535    function testOnlyGettingFieldFromFocusedFrame() {
536        $frame1 = &new MockSimplePage();
537        $frame1->setReturnValue('getField', 'f', array(new SimpleByName('a')));
538
539        $frame2 = &new MockSimplePage();
540        $frame2->expectNever('getField');
541
542        $frameset = &new SimpleFrameset(new MockSimplePage());
543        $frameset->addFrame($frame1, 'A');
544        $frameset->addFrame($frame2, 'B');
545        $frameset->setFrameFocus('A');
546        $this->assertIdentical($frameset->getField(new SimpleByName('a')), 'f');
547    }
548}
549?>
Note: See TracBrowser for help on using the repository browser.