← Back to branch summary

~budgester/irm/trunk

« back to all changes in this revision

Viewing changes to testing/simpletest/test/browser_test.php

  • Committer: budgester at budgester
  • Date: 2008-03-05 23:14:13 UTC
  • Revision ID: budgester@budgester.com-20080305231413-k5vqfuckfo09ju42
Initial import of IRM codebase

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/simpletest/test/browser_test.php
 
1
<?php
 
2
    // $Id: browser_test.php,v 1.114 2005/09/09 01:27:38 lastcraft Exp $
 
3
 
 
4
    require_once(dirname(__FILE__) . '/../browser.php');
 
5
    require_once(dirname(__FILE__) . '/../user_agent.php');
 
6
    require_once(dirname(__FILE__) . '/../http.php');
 
7
    require_once(dirname(__FILE__) . '/../page.php');
 
8
    require_once(dirname(__FILE__) . '/../encoding.php');
 
9
 
 
10
    Mock::generate('SimpleHttpResponse');
 
11
    Mock::generate('SimplePage');
 
12
    Mock::generate('SimpleForm');
 
13
    Mock::generate('SimpleUserAgent');
 
14
    Mock::generatePartial(
 
15
            'SimpleBrowser',
 
16
            'MockParseSimpleBrowser',
 
17
            array('_createUserAgent', '_parse'));
 
18
    Mock::generatePartial(
 
19
            'SimpleBrowser',
 
20
            'MockUserAgentSimpleBrowser',
 
21
            array('_createUserAgent'));
 
22
 
 
23
    class TestOfHistory extends UnitTestCase {
 
24
 
 
25
        function testEmptyHistoryHasFalseContents() {
 
26
            $history = &new SimpleBrowserHistory();
 
27
            $this->assertIdentical($history->getUrl(), false);
 
28
            $this->assertIdentical($history->getParameters(), false);
 
29
        }
 
30
 
 
31
        function testCannotMoveInEmptyHistory() {
 
32
            $history = &new SimpleBrowserHistory();
 
33
            $this->assertFalse($history->back());
 
34
            $this->assertFalse($history->forward());
 
35
        }
 
36
 
 
37
        function testCurrentTargetAccessors() {
 
38
            $history = &new SimpleBrowserHistory();
 
39
            $history->recordEntry(
 
40
                    new SimpleUrl('http://www.here.com/'),
 
41
                    new SimpleGetEncoding());
 
42
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.here.com/'));
 
43
            $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
 
44
        }
 
45
 
 
46
        function testSecondEntryAccessors() {
 
47
            $history = &new SimpleBrowserHistory();
 
48
            $history->recordEntry(
 
49
                    new SimpleUrl('http://www.first.com/'),
 
50
                    new SimpleGetEncoding());
 
51
            $history->recordEntry(
 
52
                    new SimpleUrl('http://www.second.com/'),
 
53
                    new SimplePostEncoding(array('a' => 1)));
 
54
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.second.com/'));
 
55
            $this->assertIdentical(
 
56
                    $history->getParameters(),
 
57
                    new SimplePostEncoding(array('a' => 1)));
 
58
        }
 
59
 
 
60
        function testGoingBackwards() {
 
61
            $history = &new SimpleBrowserHistory();
 
62
            $history->recordEntry(
 
63
                    new SimpleUrl('http://www.first.com/'),
 
64
                    new SimpleGetEncoding());
 
65
            $history->recordEntry(
 
66
                    new SimpleUrl('http://www.second.com/'),
 
67
                    new SimplePostEncoding(array('a' => 1)));
 
68
            $this->assertTrue($history->back());
 
69
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
 
70
            $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
 
71
        }
 
72
 
 
73
        function testGoingBackwardsOffBeginning() {
 
74
            $history = &new SimpleBrowserHistory();
 
75
            $history->recordEntry(
 
76
                    new SimpleUrl('http://www.first.com/'),
 
77
                    new SimpleGetEncoding());
 
78
            $this->assertFalse($history->back());
 
79
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
 
80
            $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
 
81
        }
 
82
 
 
83
        function testGoingForwardsOffEnd() {
 
84
            $history = &new SimpleBrowserHistory();
 
85
            $history->recordEntry(
 
86
                    new SimpleUrl('http://www.first.com/'),
 
87
                    new SimpleGetEncoding());
 
88
            $this->assertFalse($history->forward());
 
89
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
 
90
            $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
 
91
        }
 
92
 
 
93
        function testGoingBackwardsAndForwards() {
 
94
            $history = &new SimpleBrowserHistory();
 
95
            $history->recordEntry(
 
96
                    new SimpleUrl('http://www.first.com/'),
 
97
                    new SimpleGetEncoding());
 
98
            $history->recordEntry(
 
99
                    new SimpleUrl('http://www.second.com/'),
 
100
                    new SimplePostEncoding(array('a' => 1)));
 
101
            $this->assertTrue($history->back());
 
102
            $this->assertTrue($history->forward());
 
103
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.second.com/'));
 
104
            $this->assertIdentical(
 
105
                    $history->getParameters(),
 
106
                    new SimplePostEncoding(array('a' => 1)));
 
107
        }
 
108
 
 
109
        function testNewEntryReplacesNextOne() {
 
110
            $history = &new SimpleBrowserHistory();
 
111
            $history->recordEntry(
 
112
                    new SimpleUrl('http://www.first.com/'),
 
113
                    new SimpleGetEncoding());
 
114
            $history->recordEntry(
 
115
                    new SimpleUrl('http://www.second.com/'),
 
116
                    new SimplePostEncoding(array('a' => 1)));
 
117
            $history->back();
 
118
            $history->recordEntry(
 
119
                    new SimpleUrl('http://www.third.com/'),
 
120
                    new SimpleGetEncoding());
 
121
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.third.com/'));
 
122
            $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
 
123
        }
 
124
 
 
125
        function testNewEntryDropsFutureEntries() {
 
126
            $history = &new SimpleBrowserHistory();
 
127
            $history->recordEntry(
 
128
                    new SimpleUrl('http://www.first.com/'),
 
129
                    new SimpleGetEncoding());
 
130
            $history->recordEntry(
 
131
                    new SimpleUrl('http://www.second.com/'),
 
132
                    new SimpleGetEncoding());
 
133
            $history->recordEntry(
 
134
                    new SimpleUrl('http://www.third.com/'),
 
135
                    new SimpleGetEncoding());
 
136
            $history->back();
 
137
            $history->back();
 
138
            $history->recordEntry(
 
139
                    new SimpleUrl('http://www.fourth.com/'),
 
140
                    new SimpleGetEncoding());
 
141
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.fourth.com/'));
 
142
            $this->assertFalse($history->forward());
 
143
            $history->back();
 
144
            $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
 
145
            $this->assertFalse($history->back());
 
146
        }
 
147
    }
 
148
 
 
149
    class TestOfParsedPageAccess extends UnitTestCase {
 
150
 
 
151
        function &loadPage(&$page) {
 
152
            $response = &new MockSimpleHttpResponse($this);
 
153
 
 
154
            $agent = &new MockSimpleUserAgent($this);
 
155
            $agent->setReturnReference('fetchResponse', $response);
 
156
 
 
157
            $browser = &new MockParseSimpleBrowser($this);
 
158
            $browser->setReturnReference('_createUserAgent', $agent);
 
159
            $browser->setReturnReference('_parse', $page);
 
160
            $browser->SimpleBrowser();
 
161
 
 
162
            $browser->get('http://this.com/page.html');
 
163
            return $browser;
 
164
        }
 
165
 
 
166
        function testAccessorsWhenNoPage() {
 
167
            $agent = &new MockSimpleUserAgent($this);
 
168
 
 
169
            $browser = &new MockParseSimpleBrowser($this);
 
170
            $browser->setReturnReference('_createUserAgent', $agent);
 
171
            $browser->SimpleBrowser();
 
172
 
 
173
            $this->assertEqual($browser->getContent(), '');
 
174
        }
 
175
 
 
176
        function testParse() {
 
177
            $page = &new MockSimplePage();
 
178
            $page->setReturnValue('getRequest', "GET here.html\r\n\r\n");
 
179
            $page->setReturnValue('getRaw', 'Raw HTML');
 
180
            $page->setReturnValue('getTitle', 'Here');
 
181
            $page->setReturnValue('getFrameFocus', 'Frame');
 
182
            $page->setReturnValue('getMimeType', 'text/html');
 
183
            $page->setReturnValue('getResponseCode', 200);
 
184
            $page->setReturnValue('getAuthentication', 'Basic');
 
185
            $page->setReturnValue('getRealm', 'Somewhere');
 
186
            $page->setReturnValue('getTransportError', 'Ouch!');
 
187
 
 
188
            $browser = &$this->loadPage($page);
 
189
 
 
190
            $this->assertEqual($browser->getRequest(), "GET here.html\r\n\r\n");
 
191
            $this->assertEqual($browser->getContent(), 'Raw HTML');
 
192
            $this->assertEqual($browser->getTitle(), 'Here');
 
193
            $this->assertEqual($browser->getFrameFocus(), 'Frame');
 
194
            $this->assertIdentical($browser->getResponseCode(), 200);
 
195
            $this->assertEqual($browser->getMimeType(), 'text/html');
 
196
            $this->assertEqual($browser->getAuthentication(), 'Basic');
 
197
            $this->assertEqual($browser->getRealm(), 'Somewhere');
 
198
            $this->assertEqual($browser->getTransportError(), 'Ouch!');
 
199
        }
 
200
 
 
201
        function testLinkAffirmationWhenPresent() {
 
202
            $page = &new MockSimplePage();
 
203
            $page->setReturnValue('getUrlsByLabel', array('http://www.nowhere.com'));
 
204
            $page->expectOnce('getUrlsByLabel', array('a link label'));
 
205
            $browser = &$this->loadPage($page);
 
206
            $this->assertTrue($browser->isLink('a link label'));
 
207
        }
 
208
 
 
209
        function testLinkAffirmationByIdWhenPresent() {
 
210
            $page = &new MockSimplePage();
 
211
            $page->setReturnValue('getUrlById', true, array(99));
 
212
            $page->setReturnValue('getUrlById', false, array('*'));
 
213
            $browser = &$this->loadPage($page);
 
214
            $this->assertTrue($browser->isLinkById(99));
 
215
            $this->assertFalse($browser->isLinkById(98));
 
216
        }
 
217
 
 
218
        function testSettingFieldIsPassedToPage() {
 
219
            $page = &new MockSimplePage();
 
220
            $page->expectOnce('setField', array(new SimpleByLabelOrName('key'), 'Value'));
 
221
            $page->setReturnValue('getField', 'Value');
 
222
            $browser = &$this->loadPage($page);
 
223
            $this->assertEqual($browser->getField('key'), 'Value');
 
224
            $browser->setField('key', 'Value');
 
225
        }
 
226
    }
 
227
 
 
228
    class TestOfBrowserNavigation extends UnitTestCase {
 
229
 
 
230
        function &createBrowser(&$agent, &$page) {
 
231
            $browser = &new MockParseSimpleBrowser();
 
232
            $browser->setReturnReference('_createUserAgent', $agent);
 
233
            $browser->setReturnReference('_parse', $page);
 
234
            $browser->SimpleBrowser();
 
235
            return $browser;
 
236
        }
 
237
 
 
238
        function testClickLinkRequestsPage() {
 
239
            $agent = &new MockSimpleUserAgent();
 
240
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
241
            $agent->expectArgumentsAt(
 
242
                    0,
 
243
                    'fetchResponse',
 
244
                    array(new SimpleUrl('http://this.com/page.html'), new SimpleGetEncoding()));
 
245
            $agent->expectArgumentsAt(
 
246
                    1,
 
247
                    'fetchResponse',
 
248
                    array(new SimpleUrl('http://this.com/new.html'), new SimpleGetEncoding()));
 
249
            $agent->expectCallCount('fetchResponse', 2);
 
250
 
 
251
            $page = &new MockSimplePage();
 
252
            $page->setReturnValue('getUrlsByLabel', array(new SimpleUrl('http://this.com/new.html')));
 
253
            $page->expectOnce('getUrlsByLabel', array('New'));
 
254
            $page->setReturnValue('getRaw', 'A page');
 
255
 
 
256
            $browser = &$this->createBrowser($agent, $page);
 
257
            $browser->get('http://this.com/page.html');
 
258
            $this->assertTrue($browser->clickLink('New'));
 
259
        }
 
260
 
 
261
        function testClickLinkWithUnknownFrameStillRequestsWholePage() {
 
262
            $agent = &new MockSimpleUserAgent();
 
263
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
264
            $agent->expectArgumentsAt(
 
265
                    0,
 
266
                    'fetchResponse',
 
267
                    array(new SimpleUrl('http://this.com/page.html'), new SimpleGetEncoding()));
 
268
            $target = new SimpleUrl('http://this.com/new.html');
 
269
            $target->setTarget('missing');
 
270
            $agent->expectArgumentsAt(
 
271
                    1,
 
272
                    'fetchResponse',
 
273
                    array($target, new SimpleGetEncoding()));
 
274
            $agent->expectCallCount('fetchResponse', 2);
 
275
 
 
276
            $parsed_url = new SimpleUrl('http://this.com/new.html');
 
277
            $parsed_url->setTarget('missing');
 
278
 
 
279
            $page = &new MockSimplePage();
 
280
            $page->setReturnValue('getUrlsByLabel', array($parsed_url));
 
281
            $page->setReturnValue('hasFrames', false);
 
282
            $page->expectOnce('getUrlsByLabel', array('New'));
 
283
            $page->setReturnValue('getRaw', 'A page');
 
284
 
 
285
            $browser = &$this->createBrowser($agent, $page);
 
286
            $browser->get('http://this.com/page.html');
 
287
            $this->assertTrue($browser->clickLink('New'));
 
288
        }
 
289
 
 
290
        function testClickingMissingLinkFails() {
 
291
            $agent = &new MockSimpleUserAgent($this);
 
292
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
293
 
 
294
            $page = &new MockSimplePage();
 
295
            $page->setReturnValue('getUrlsByLabel', array());
 
296
            $page->setReturnValue('getRaw', 'stuff');
 
297
 
 
298
            $browser = &$this->createBrowser($agent, $page);
 
299
            $this->assertTrue($browser->get('http://this.com/page.html'));
 
300
            $this->assertFalse($browser->clickLink('New'));
 
301
        }
 
302
 
 
303
        function testClickIndexedLink() {
 
304
            $agent = &new MockSimpleUserAgent();
 
305
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
306
            $agent->expectArgumentsAt(
 
307
                    1,
 
308
                    'fetchResponse',
 
309
                    array(new SimpleUrl('1.html'), new SimpleGetEncoding()));
 
310
            $agent->expectCallCount('fetchResponse', 2);
 
311
 
 
312
            $page = &new MockSimplePage();
 
313
            $page->setReturnValue(
 
314
                    'getUrlsByLabel',
 
315
                    array(new SimpleUrl('0.html'), new SimpleUrl('1.html')));
 
316
            $page->setReturnValue('getRaw', 'A page');
 
317
 
 
318
            $browser = &$this->createBrowser($agent, $page);
 
319
            $browser->get('http://this.com/page.html');
 
320
            $this->assertTrue($browser->clickLink('New', 1));
 
321
        }
 
322
 
 
323
        function testClinkLinkById() {
 
324
            $agent = &new MockSimpleUserAgent();
 
325
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
326
            $agent->expectArgumentsAt(1, 'fetchResponse', array(
 
327
                    new SimpleUrl('http://this.com/link.html'),
 
328
                    new SimpleGetEncoding()));
 
329
            $agent->expectCallCount('fetchResponse', 2);
 
330
 
 
331
            $page = &new MockSimplePage();
 
332
            $page->setReturnValue('getUrlById', new SimpleUrl('http://this.com/link.html'));
 
333
            $page->expectOnce('getUrlById', array(2));
 
334
            $page->setReturnValue('getRaw', 'A page');
 
335
 
 
336
            $browser = &$this->createBrowser($agent, $page);
 
337
            $browser->get('http://this.com/page.html');
 
338
            $this->assertTrue($browser->clickLinkById(2));
 
339
        }
 
340
 
 
341
        function testClickingMissingLinkIdFails() {
 
342
            $agent = &new MockSimpleUserAgent();
 
343
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
344
 
 
345
            $page = &new MockSimplePage();
 
346
            $page->setReturnValue('getUrlById', false);
 
347
 
 
348
            $browser = &$this->createBrowser($agent, $page);
 
349
            $browser->get('http://this.com/page.html');
 
350
            $this->assertFalse($browser->clickLink(0));
 
351
        }
 
352
 
 
353
        function testSubmitFormByLabel() {
 
354
            $agent = &new MockSimpleUserAgent();
 
355
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
356
            $agent->expectArgumentsAt(1, 'fetchResponse', array(
 
357
                    new SimpleUrl('http://this.com/handler.html'),
 
358
                    new SimplePostEncoding(array('a' => 'A'))));
 
359
            $agent->expectCallCount('fetchResponse', 2);
 
360
 
 
361
            $form = &new MockSimpleForm();
 
362
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
363
            $form->setReturnValue('getMethod', 'post');
 
364
            $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
 
365
            $form->expectOnce('submitButton', array(new SimpleByLabel('Go'), false));
 
366
 
 
367
            $page = &new MockSimplePage();
 
368
            $page->setReturnReference('getFormBySubmit', $form);
 
369
            $page->expectOnce('getFormBySubmit', array(new SimpleByLabel('Go')));
 
370
            $page->setReturnValue('getRaw', 'stuff');
 
371
 
 
372
            $browser = &$this->createBrowser($agent, $page);
 
373
            $browser->get('http://this.com/page.html');
 
374
            $this->assertTrue($browser->clickSubmit('Go'));
 
375
        }
 
376
 
 
377
        function testDefaultSubmitFormByLabel() {
 
378
            $agent = &new MockSimpleUserAgent();
 
379
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
380
            $agent->expectArgumentsAt(1,  'fetchResponse', array(
 
381
                    new SimpleUrl('http://this.com/page.html'),
 
382
                    new SimpleGetEncoding(array('a' => 'A'))));
 
383
            $agent->expectCallCount('fetchResponse', 2);
 
384
 
 
385
            $form = &new MockSimpleForm();
 
386
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/page.html'));
 
387
            $form->setReturnValue('getMethod', 'get');
 
388
            $form->setReturnValue('submitButton', new SimpleGetEncoding(array('a' => 'A')));
 
389
 
 
390
            $page = &new MockSimplePage();
 
391
            $page->setReturnReference('getFormBySubmit', $form);
 
392
            $page->expectOnce('getFormBySubmit', array(new SimpleByLabel('Submit')));
 
393
            $page->setReturnValue('getRaw', 'stuff');
 
394
            $page->setReturnValue('getUrl', new SimpleUrl('http://this.com/page.html'));
 
395
 
 
396
            $browser = &$this->createBrowser($agent, $page);
 
397
            $browser->get('http://this.com/page.html');
 
398
            $this->assertTrue($browser->clickSubmit());
 
399
        }
 
400
 
 
401
        function testSubmitFormByName() {
 
402
            $agent = &new MockSimpleUserAgent();
 
403
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
404
 
 
405
            $form = &new MockSimpleForm();
 
406
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
407
            $form->setReturnValue('getMethod', 'post');
 
408
            $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
 
409
 
 
410
            $page = &new MockSimplePage();
 
411
            $page->setReturnReference('getFormBySubmit', $form);
 
412
            $page->expectOnce('getFormBySubmit', array(new SimpleByName('me')));
 
413
            $page->setReturnValue('getRaw', 'stuff');
 
414
 
 
415
            $browser = &$this->createBrowser($agent, $page);
 
416
            $browser->get('http://this.com/page.html');
 
417
            $this->assertTrue($browser->clickSubmitByName('me'));
 
418
        }
 
419
 
 
420
        function testSubmitFormById() {
 
421
            $agent = &new MockSimpleUserAgent();
 
422
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
423
 
 
424
            $form = &new MockSimpleForm();
 
425
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
426
            $form->setReturnValue('getMethod', 'post');
 
427
            $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
 
428
            $form->expectOnce('submitButton', array(new SimpleById(99), false));
 
429
 
 
430
            $page = &new MockSimplePage();
 
431
            $page->setReturnReference('getFormBySubmit', $form);
 
432
            $page->expectOnce('getFormBySubmit', array(new SimpleById(99)));
 
433
            $page->setReturnValue('getRaw', 'stuff');
 
434
 
 
435
            $browser = &$this->createBrowser($agent, $page);
 
436
            $browser->get('http://this.com/page.html');
 
437
            $this->assertTrue($browser->clickSubmitById(99));
 
438
        }
 
439
 
 
440
        function testSubmitFormByImageLabel() {
 
441
            $agent = &new MockSimpleUserAgent();
 
442
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
443
 
 
444
            $form = &new MockSimpleForm();
 
445
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
446
            $form->setReturnValue('getMethod', 'post');
 
447
            $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
 
448
            $form->expectOnce('submitImage', array(new SimpleByLabel('Go!'), 10, 11, false));
 
449
 
 
450
            $page = &new MockSimplePage();
 
451
            $page->setReturnReference('getFormByImage', $form);
 
452
            $page->expectOnce('getFormByImage', array(new SimpleByLabel('Go!')));
 
453
            $page->setReturnValue('getRaw', 'stuff');
 
454
 
 
455
            $browser = &$this->createBrowser($agent, $page);
 
456
            $browser->get('http://this.com/page.html');
 
457
            $this->assertTrue($browser->clickImage('Go!', 10, 11));
 
458
        }
 
459
 
 
460
        function testSubmitFormByImageName() {
 
461
            $agent = &new MockSimpleUserAgent();
 
462
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
463
 
 
464
            $form = &new MockSimpleForm();
 
465
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
466
            $form->setReturnValue('getMethod', 'post');
 
467
            $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
 
468
            $form->expectOnce('submitImage', array(new SimpleByName('a'), 10, 11, false));
 
469
 
 
470
            $page = &new MockSimplePage();
 
471
            $page->setReturnReference('getFormByImage', $form);
 
472
            $page->expectOnce('getFormByImage', array(new SimpleByName('a')));
 
473
            $page->setReturnValue('getRaw', 'stuff');
 
474
 
 
475
            $browser = &$this->createBrowser($agent, $page);
 
476
            $browser->get('http://this.com/page.html');
 
477
            $this->assertTrue($browser->clickImageByName('a', 10, 11));
 
478
        }
 
479
 
 
480
        function testSubmitFormByImageId() {
 
481
            $agent = &new MockSimpleUserAgent();
 
482
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
483
 
 
484
            $form = &new MockSimpleForm();
 
485
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
486
            $form->setReturnValue('getMethod', 'post');
 
487
            $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
 
488
            $form->expectOnce('submitImage', array(new SimpleById(99), 10, 11, false));
 
489
 
 
490
            $page = &new MockSimplePage();
 
491
            $page->setReturnReference('getFormByImage', $form);
 
492
            $page->expectOnce('getFormByImage', array(new SimpleById(99)));
 
493
            $page->setReturnValue('getRaw', 'stuff');
 
494
 
 
495
            $browser = &$this->createBrowser($agent, $page);
 
496
            $browser->get('http://this.com/page.html');
 
497
            $this->assertTrue($browser->clickImageById(99, 10, 11));
 
498
        }
 
499
 
 
500
        function testSubmitFormByFormId() {
 
501
            $agent = &new MockSimpleUserAgent();
 
502
            $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
 
503
            $agent->expectArgumentsAt(1, 'fetchResponse', array(
 
504
                    new SimpleUrl('http://this.com/handler.html'),
 
505
                    new SimplePostEncoding(array('a' => 'A'))));
 
506
            $agent->expectCallCount('fetchResponse', 2);
 
507
 
 
508
            $form = &new MockSimpleForm();
 
509
            $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
 
510
            $form->setReturnValue('getMethod', 'post');
 
511
            $form->setReturnValue('submit', new SimplePostEncoding(array('a' => 'A')));
 
512
 
 
513
            $page = &new MockSimplePage();
 
514
            $page->setReturnReference('getFormById', $form);
 
515
            $page->expectOnce('getFormById', array(33));
 
516
            $page->setReturnValue('getRaw', 'stuff');
 
517
 
 
518
            $browser = &$this->createBrowser($agent, $page);
 
519
            $browser->get('http://this.com/page.html');
 
520
            $this->assertTrue($browser->submitFormById(33));
 
521
        }
 
522
    }
 
523
 
 
524
    class TestOfBrowserFrames extends UnitTestCase {
 
525
 
 
526
        function &createBrowser(&$agent) {
 
527
            $browser = &new MockUserAgentSimpleBrowser();
 
528
            $browser->setReturnReference('_createUserAgent', $agent);
 
529
            $browser->SimpleBrowser();
 
530
            return $browser;
 
531
        }
 
532
 
 
533
        function &createUserAgent($pages) {
 
534
            $agent = &new MockSimpleUserAgent();
 
535
            foreach ($pages as $url => $raw) {
 
536
                $url = new SimpleUrl($url);
 
537
                $response = &new MockSimpleHttpResponse();
 
538
                $response->setReturnValue('getUrl', $url);
 
539
                $response->setReturnValue('getContent', $raw);
 
540
                $agent->setReturnReference('fetchResponse', $response, array($url, '*'));
 
541
            }
 
542
            return $agent;
 
543
        }
 
544
 
 
545
        function testSimplePageHasNoFrames() {
 
546
            $browser = &$this->createBrowser($this->createUserAgent(
 
547
                    array('http://site.with.no.frames/' => 'A non-framed page')));
 
548
            $this->assertEqual(
 
549
                    $browser->get('http://site.with.no.frames/'),
 
550
                    'A non-framed page');
 
551
            $this->assertIdentical($browser->getFrames(), 'http://site.with.no.frames/');
 
552
        }
 
553
 
 
554
        function testFramesetWithNoFrames() {
 
555
            $browser = &$this->createBrowser($this->createUserAgent(
 
556
                    array('http://site.with.no.frames/' => '<frameset></frameset>')));
 
557
            $this->assertEqual(
 
558
                    $browser->get('http://site.with.no.frames/'),
 
559
                    '');
 
560
            $this->assertIdentical($browser->getFrames(), array());
 
561
        }
 
562
 
 
563
        function testFramesetWithSingleFrame() {
 
564
            $frameset = '<frameset><frame name="a" src="frame.html"></frameset>';
 
565
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
566
                    'http://site.with.one.frame/' => $frameset,
 
567
                    'http://site.with.one.frame/frame.html' => 'A frame')));
 
568
 
 
569
            $this->assertEqual(
 
570
                    $browser->get('http://site.with.one.frame/'),
 
571
                    'A frame');
 
572
            $this->assertIdentical(
 
573
                    $browser->getFrames(),
 
574
                    array('a' => 'http://site.with.one.frame/frame.html'));
 
575
        }
 
576
 
 
577
        function testTitleTakenFromFramesetPage() {
 
578
            $frameset = '<title>Frameset title</title>' .
 
579
                    '<frameset><frame name="a" src="frame.html"></frameset>';
 
580
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
581
                    'http://site.with.one.frame/' => $frameset,
 
582
                    'http://site.with.one.frame/frame.html' => '<title>Page title</title>')));
 
583
 
 
584
            $browser->get('http://site.with.one.frame/');
 
585
            $this->assertEqual($browser->getTitle(), 'Frameset title');
 
586
        }
 
587
 
 
588
        function testFramesetWithSingleUnnamedFrame() {
 
589
            $frameset = '<frameset><frame src="frame.html"></frameset>';
 
590
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
591
                    'http://site.with.one.frame/' => $frameset,
 
592
                    'http://site.with.one.frame/frame.html' => 'One frame')));
 
593
 
 
594
            $this->assertEqual(
 
595
                    $browser->get('http://site.with.one.frame/'),
 
596
                    'One frame');
 
597
            $this->assertIdentical(
 
598
                    $browser->getFrames(),
 
599
                    array(1 => 'http://site.with.one.frame/frame.html'));
 
600
        }
 
601
 
 
602
        function testFramesetWithMultipleFrames() {
 
603
            $frameset = '<frameset>' .
 
604
                    '<frame name="a" src="frame_a.html">' .
 
605
                    '<frame name="b" src="frame_b.html">' .
 
606
                    '<frame name="c" src="frame_c.html">' .
 
607
                    '</frameset>';
 
608
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
609
                    'http://site.with.frames/' => $frameset,
 
610
                    'http://site.with.frames/frame_a.html' => 'A frame',
 
611
                    'http://site.with.frames/frame_b.html' => 'B frame',
 
612
                    'http://site.with.frames/frame_c.html' => 'C frame')));
 
613
 
 
614
            $this->assertEqual(
 
615
                    $browser->get('http://site.with.frames/'),
 
616
                    'A frameB frameC frame');
 
617
            $this->assertIdentical($browser->getFrames(), array(
 
618
                    'a' => 'http://site.with.frames/frame_a.html',
 
619
                    'b' => 'http://site.with.frames/frame_b.html',
 
620
                    'c' => 'http://site.with.frames/frame_c.html'));
 
621
        }
 
622
 
 
623
        function testFrameFocusByName() {
 
624
            $frameset = '<frameset>' .
 
625
                    '<frame name="a" src="frame_a.html">' .
 
626
                    '<frame name="b" src="frame_b.html">' .
 
627
                    '<frame name="c" src="frame_c.html">' .
 
628
                    '</frameset>';
 
629
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
630
                    'http://site.with.frames/' => $frameset,
 
631
                    'http://site.with.frames/frame_a.html' => 'A frame',
 
632
                    'http://site.with.frames/frame_b.html' => 'B frame',
 
633
                    'http://site.with.frames/frame_c.html' => 'C frame')));
 
634
 
 
635
            $browser->get('http://site.with.frames/');
 
636
            $browser->setFrameFocus('a');
 
637
            $this->assertEqual($browser->getContent(), 'A frame');
 
638
            $browser->setFrameFocus('b');
 
639
            $this->assertEqual($browser->getContent(), 'B frame');
 
640
            $browser->setFrameFocus('c');
 
641
            $this->assertEqual($browser->getContent(), 'C frame');
 
642
        }
 
643
 
 
644
        function testFramesetWithSomeNamedFrames() {
 
645
            $frameset = '<frameset>' .
 
646
                    '<frame name="a" src="frame_a.html">' .
 
647
                    '<frame src="frame_b.html">' .
 
648
                    '<frame name="c" src="frame_c.html">' .
 
649
                    '<frame src="frame_d.html">' .
 
650
                    '</frameset>';
 
651
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
652
                    'http://site.with.frames/' => $frameset,
 
653
                    'http://site.with.frames/frame_a.html' => 'A frame',
 
654
                    'http://site.with.frames/frame_b.html' => 'B frame',
 
655
                    'http://site.with.frames/frame_c.html' => 'C frame',
 
656
                    'http://site.with.frames/frame_d.html' => 'D frame')));
 
657
 
 
658
            $this->assertEqual(
 
659
                    $browser->get('http://site.with.frames/'),
 
660
                    'A frameB frameC frameD frame');
 
661
            $this->assertIdentical($browser->getFrames(), array(
 
662
                    'a' => 'http://site.with.frames/frame_a.html',
 
663
                    2 => 'http://site.with.frames/frame_b.html',
 
664
                    'c' => 'http://site.with.frames/frame_c.html',
 
665
                    4 => 'http://site.with.frames/frame_d.html'));
 
666
        }
 
667
 
 
668
        function testFrameFocusWithMixedNamesAndIndexes() {
 
669
            $frameset = '<frameset>' .
 
670
                    '<frame name="a" src="frame_a.html">' .
 
671
                    '<frame src="frame_b.html">' .
 
672
                    '<frame name="c" src="frame_c.html">' .
 
673
                    '<frame src="frame_d.html">' .
 
674
                    '</frameset>';
 
675
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
676
                    'http://site.with.frames/' => $frameset,
 
677
                    'http://site.with.frames/frame_a.html' => 'A frame',
 
678
                    'http://site.with.frames/frame_b.html' => 'B frame',
 
679
                    'http://site.with.frames/frame_c.html' => 'C frame',
 
680
                    'http://site.with.frames/frame_d.html' => 'D frame')));
 
681
 
 
682
            $browser->get('http://site.with.frames/');
 
683
            $browser->setFrameFocus('a');
 
684
            $this->assertEqual($browser->getContent(), 'A frame');
 
685
            $browser->setFrameFocus(2);
 
686
            $this->assertEqual($browser->getContent(), 'B frame');
 
687
            $browser->setFrameFocus('c');
 
688
            $this->assertEqual($browser->getContent(), 'C frame');
 
689
            $browser->setFrameFocus(4);
 
690
            $this->assertEqual($browser->getContent(), 'D frame');
 
691
            $browser->clearFrameFocus();
 
692
            $this->assertEqual($browser->getContent(), 'A frameB frameC frameD frame');
 
693
        }
 
694
 
 
695
        function testNestedFrameset() {
 
696
            $inner = '<frameset>' .
 
697
                    '<frame name="page" src="page.html">' .
 
698
                    '</frameset>';
 
699
            $outer = '<frameset>' .
 
700
                    '<frame name="inner" src="inner.html">' .
 
701
                    '</frameset>';
 
702
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
703
                    'http://site.with.nested.frame/' => $outer,
 
704
                    'http://site.with.nested.frame/inner.html' => $inner,
 
705
                    'http://site.with.nested.frame/page.html' => 'The page')));
 
706
 
 
707
            $this->assertEqual(
 
708
                    $browser->get('http://site.with.nested.frame/'),
 
709
                    'The page');
 
710
            $this->assertIdentical($browser->getFrames(), array(
 
711
                    'inner' => array(
 
712
                            'page' => 'http://site.with.nested.frame/page.html')));
 
713
        }
 
714
 
 
715
        function testCanNavigateToNestedFrame() {
 
716
            $inner = '<frameset>' .
 
717
                    '<frame name="one" src="one.html">' .
 
718
                    '<frame name="two" src="two.html">' .
 
719
                    '</frameset>';
 
720
            $outer = '<frameset>' .
 
721
                    '<frame name="inner" src="inner.html">' .
 
722
                    '<frame name="three" src="three.html">' .
 
723
                    '</frameset>';
 
724
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
725
                    'http://site.with.nested.frames/' => $outer,
 
726
                    'http://site.with.nested.frames/inner.html' => $inner,
 
727
                    'http://site.with.nested.frames/one.html' => 'Page one',
 
728
                    'http://site.with.nested.frames/two.html' => 'Page two',
 
729
                    'http://site.with.nested.frames/three.html' => 'Page three')));
 
730
 
 
731
            $browser->get('http://site.with.nested.frames/');
 
732
            $this->assertEqual($browser->getContent(), 'Page onePage twoPage three');
 
733
 
 
734
            $this->assertTrue($browser->setFrameFocus('inner'));
 
735
            $this->assertEqual($browser->getFrameFocus(), array('inner'));
 
736
            $this->assertTrue($browser->setFrameFocus('one'));
 
737
            $this->assertEqual($browser->getFrameFocus(), array('inner', 'one'));
 
738
            $this->assertEqual($browser->getContent(), 'Page one');
 
739
 
 
740
            $this->assertTrue($browser->setFrameFocus('two'));
 
741
            $this->assertEqual($browser->getFrameFocus(), array('inner', 'two'));
 
742
            $this->assertEqual($browser->getContent(), 'Page two');
 
743
 
 
744
            $browser->clearFrameFocus();
 
745
            $this->assertTrue($browser->setFrameFocus('three'));
 
746
            $this->assertEqual($browser->getFrameFocus(), array('three'));
 
747
            $this->assertEqual($browser->getContent(), 'Page three');
 
748
 
 
749
            $this->assertTrue($browser->setFrameFocus('inner'));
 
750
            $this->assertEqual($browser->getContent(), 'Page onePage two');
 
751
        }
 
752
 
 
753
        function testCanNavigateToNestedFrameByIndex() {
 
754
            $inner = '<frameset>' .
 
755
                    '<frame src="one.html">' .
 
756
                    '<frame src="two.html">' .
 
757
                    '</frameset>';
 
758
            $outer = '<frameset>' .
 
759
                    '<frame src="inner.html">' .
 
760
                    '<frame src="three.html">' .
 
761
                    '</frameset>';
 
762
            $browser = &$this->createBrowser($this->createUserAgent(array(
 
763
                    'http://site.with.nested.frames/' => $outer,
 
764
                    'http://site.with.nested.frames/inner.html' => $inner,
 
765
                    'http://site.with.nested.frames/one.html' => 'Page one',
 
766
                    'http://site.with.nested.frames/two.html' => 'Page two',
 
767
                    'http://site.with.nested.frames/three.html' => 'Page three')));
 
768
 
 
769
            $browser->get('http://site.with.nested.frames/');
 
770
            $this->assertEqual($browser->getContent(), 'Page onePage twoPage three');
 
771
 
 
772
            $this->assertTrue($browser->setFrameFocusByIndex(1));
 
773
            $this->assertEqual($browser->getFrameFocus(), array(1));
 
774
            $this->assertTrue($browser->setFrameFocusByIndex(1));
 
775
            $this->assertEqual($browser->getFrameFocus(), array(1, 1));
 
776
            $this->assertEqual($browser->getContent(), 'Page one');
 
777
 
 
778
            $this->assertTrue($browser->setFrameFocusByIndex(2));
 
779
            $this->assertEqual($browser->getFrameFocus(), array(1, 2));
 
780
            $this->assertEqual($browser->getContent(), 'Page two');
 
781
 
 
782
            $browser->clearFrameFocus();
 
783
            $this->assertTrue($browser->setFrameFocusByIndex(2));
 
784
            $this->assertEqual($browser->getFrameFocus(), array(2));
 
785
            $this->assertEqual($browser->getContent(), 'Page three');
 
786
 
 
787
            $this->assertTrue($browser->setFrameFocusByIndex(1));
 
788
            $this->assertEqual($browser->getContent(), 'Page onePage two');
 
789
        }
 
790
    }
 
791
?>
 
 
b'\\ No newline at end of file'