← Back to branch summary

~clinton-collins/familyproject/trunk

« back to all changes in this revision

Viewing changes to ZendFramework/tests/Zend/Soap/ServerTest.php

  • Committer: Clinton Collins
  • Date: 2009-06-26 19:54:58 UTC
  • Revision ID: clinton.collins@gmail.com-20090626195458-5ebba0qcvo15xlpy
Initial Import

Show diffs side-by-side

added added

removed removed

Lines of Context:
ZendFramework/tests/Zend/Soap/ServerTest.php
 
1
<?php
 
2
/**
 
3
 * Zend Framework
 
4
 *
 
5
 * LICENSE
 
6
 *
 
7
 * This source file is subject to the new BSD license that is bundled
 
8
 * with this package in the file LICENSE.txt.
 
9
 * It is also available through the world-wide-web at this URL:
 
10
 * http://framework.zend.com/license/new-bsd
 
11
 * If you did not receive a copy of the license and are unable to
 
12
 * obtain it through the world-wide-web, please send an email
 
13
 * to license@zend.com so we can send you a copy immediately.
 
14
 *
 
15
 * @category   Zend
 
16
 * @package    UnitTests
 
17
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 
18
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 
19
 */
 
20
 
 
21
require_once dirname(__FILE__)."/../../TestHelper.php";
 
22
 
 
23
/** PHPUnit Test Case */
 
24
require_once "PHPUnit/Framework/TestCase.php";
 
25
 
 
26
/** Zend_Soap_Server */
 
27
require_once 'Zend/Soap/Server.php';
 
28
 
 
29
require_once 'Zend/Soap/Server/Exception.php';
 
30
 
 
31
require_once "Zend/Config.php";
 
32
 
 
33
/**
 
34
 * Zend_Soap_Server
 
35
 *
 
36
 * @category   Zend
 
37
 * @package    UnitTests
 
38
 * @uses       Zend_Server_Interface
 
39
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 
40
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 
41
 * @version    $Id: ServerTest.php 13731 2009-01-21 12:12:15Z beberlei $
 
42
 */
 
43
class Zend_Soap_ServerTest extends PHPUnit_Framework_TestCase
 
44
{
 
45
    public function setUp()
 
46
    {
 
47
        if (!extension_loaded('soap')) {
 
48
           $this->markTestSkipped('SOAP Extension is not loaded');
 
49
        }
 
50
    }
 
51
 
 
52
    public function testSetOptions()
 
53
    {
 
54
        $server = new Zend_Soap_Server();
 
55
 
 
56
        $this->assertTrue($server->getOptions() == array('soap_version' => SOAP_1_2));
 
57
 
 
58
        $options = array('soap_version' => SOAP_1_1,
 
59
                         'actor' => 'http://framework.zend.com/Zend_Soap_ServerTest.php',
 
60
                         'classmap' => array('TestData1' => 'Zend_Soap_Server_TestData1',
 
61
                                             'TestData2' => 'Zend_Soap_Server_TestData2',),
 
62
                         'encoding' => 'ISO-8859-1',
 
63
                         'uri' => 'http://framework.zend.com/Zend_Soap_ServerTest.php'
 
64
                        );
 
65
        $server->setOptions($options);
 
66
 
 
67
        $this->assertTrue($server->getOptions() == $options);
 
68
    }
 
69
 
 
70
    public function testSetOptionsViaSecondConstructorArgument()
 
71
    {
 
72
        $options = array(
 
73
            'soap_version' => SOAP_1_1,
 
74
            'actor' => 'http://framework.zend.com/Zend_Soap_ServerTest.php',
 
75
            'classmap' => array(
 
76
                'TestData1' => 'Zend_Soap_Server_TestData1',
 
77
                'TestData2' => 'Zend_Soap_Server_TestData2',
 
78
            ),
 
79
            'encoding' => 'ISO-8859-1',
 
80
            'uri' => 'http://framework.zend.com/Zend_Soap_ServerTest.php',
 
81
        );
 
82
        $server = new Zend_Soap_Server(null, $options);
 
83
 
 
84
        $this->assertTrue($server->getOptions() == $options);
 
85
    }
 
86
 
 
87
    public function testSetWsdlViaOptionsArrayIsPossible()
 
88
    {
 
89
        $server = new Zend_Soap_Server();
 
90
        $server->setOptions(array('wsdl' => 'http://www.example.com/test.wsdl'));
 
91
 
 
92
        $this->assertEquals('http://www.example.com/test.wsdl', $server->getWsdl());
 
93
    }
 
94
 
 
95
    public function testGetOptions()
 
96
    {
 
97
        $server = new Zend_Soap_Server();
 
98
 
 
99
        $this->assertTrue($server->getOptions() == array('soap_version' => SOAP_1_2));
 
100
 
 
101
        $options = array('soap_version' => SOAP_1_1,
 
102
                         'uri' => 'http://framework.zend.com/Zend_Soap_ServerTest.php'
 
103
                        );
 
104
        $server->setOptions($options);
 
105
 
 
106
        $this->assertTrue($server->getOptions() == $options);
 
107
    }
 
108
 
 
109
    public function testEncoding()
 
110
    {
 
111
        $server = new Zend_Soap_Server();
 
112
 
 
113
        $this->assertNull($server->getEncoding());
 
114
        $server->setEncoding('ISO-8859-1');
 
115
        $this->assertEquals('ISO-8859-1', $server->getEncoding());
 
116
 
 
117
        try {
 
118
            $server->setEncoding(array('UTF-8'));
 
119
            $this->fail('Non-string encoding values should fail');
 
120
        } catch (Exception $e) {
 
121
            // success
 
122
        }
 
123
    }
 
124
 
 
125
    public function testSoapVersion()
 
126
    {
 
127
        $server = new Zend_Soap_Server();
 
128
 
 
129
        $this->assertEquals(SOAP_1_2, $server->getSoapVersion());
 
130
        $server->setSoapVersion(SOAP_1_1);
 
131
        $this->assertEquals(SOAP_1_1, $server->getSoapVersion());
 
132
        try {
 
133
            $server->setSoapVersion('bogus');
 
134
            $this->fail('Invalid soap versions should fail');
 
135
        } catch (Exception $e)  {
 
136
            // success
 
137
        }
 
138
    }
 
139
 
 
140
    public function testValidateUrn()
 
141
    {
 
142
        $server = new Zend_Soap_Server();
 
143
 
 
144
        try {
 
145
            $server->validateUrn('bogosity');
 
146
            $this->fail('URNs without schemes should fail');
 
147
        } catch (Exception $e) {
 
148
            // success
 
149
        }
 
150
 
 
151
        $this->assertTrue($server->validateUrn('http://framework.zend.com/'));
 
152
        $this->assertTrue($server->validateUrn('urn:soapHandler/GetOpt'));
 
153
    }
 
154
 
 
155
    public function testSetActor()
 
156
    {
 
157
        $server = new Zend_Soap_Server();
 
158
 
 
159
        $this->assertNull($server->getActor());
 
160
        $server->setActor('http://framework.zend.com/');
 
161
        $this->assertEquals('http://framework.zend.com/', $server->getActor());
 
162
        try {
 
163
            $server->setActor('bogus');
 
164
            $this->fail('Invalid actor should fail');
 
165
        } catch (Exception $e)  {
 
166
            // success
 
167
        }
 
168
    }
 
169
 
 
170
    public function testGetActor()
 
171
    {
 
172
        $server = new Zend_Soap_Server();
 
173
 
 
174
        $this->assertNull($server->getActor());
 
175
        $server->setActor('http://framework.zend.com/');
 
176
        $this->assertEquals('http://framework.zend.com/', $server->getActor());
 
177
    }
 
178
 
 
179
    public function testSetUri()
 
180
    {
 
181
        $server = new Zend_Soap_Server();
 
182
 
 
183
        $this->assertNull($server->getUri());
 
184
        $server->setUri('http://framework.zend.com/');
 
185
        $this->assertEquals('http://framework.zend.com/', $server->getUri());
 
186
        try {
 
187
            $server->setUri('bogus');
 
188
            $this->fail('Invalid URI should fail');
 
189
        } catch (Exception $e)  {
 
190
            // success
 
191
        }
 
192
    }
 
193
 
 
194
    public function testGetUri()
 
195
    {
 
196
        $server = new Zend_Soap_Server();
 
197
 
 
198
        $this->assertNull($server->getUri());
 
199
        $server->setUri('http://framework.zend.com/');
 
200
        $this->assertEquals('http://framework.zend.com/', $server->getUri());
 
201
    }
 
202
 
 
203
    public function testSetClassmap()
 
204
    {
 
205
        $server = new Zend_Soap_Server();
 
206
 
 
207
        $classmap = array('TestData1' => 'Zend_Soap_Server_TestData1',
 
208
                          'TestData2' => 'Zend_Soap_Server_TestData2');
 
209
 
 
210
        $this->assertNull($server->getClassmap());
 
211
        $server->setClassmap($classmap);
 
212
        $this->assertTrue($classmap == $server->getClassmap());
 
213
        try {
 
214
            $server->setClassmap('bogus');
 
215
            $this->fail('Classmap which is not an array should fail');
 
216
        } catch (Exception $e)  {
 
217
            // success
 
218
        }
 
219
        try {
 
220
            $server->setClassmap(array('soapTypeName', 'bogusClassName'));
 
221
            $this->fail('Invalid class within classmap should fail');
 
222
        } catch (Exception $e)  {
 
223
            // success
 
224
        }
 
225
    }
 
226
 
 
227
    public function testGetClassmap()
 
228
    {
 
229
        $server = new Zend_Soap_Server();
 
230
 
 
231
        $classmap = array('TestData1' => 'Zend_Soap_Server_TestData1',
 
232
                          'TestData2' => 'Zend_Soap_Server_TestData2');
 
233
 
 
234
        $this->assertNull($server->getClassmap());
 
235
        $server->setClassmap($classmap);
 
236
        $this->assertTrue($classmap == $server->getClassmap());
 
237
    }
 
238
 
 
239
    public function testSetWsdl()
 
240
    {
 
241
        $server = new Zend_Soap_Server();
 
242
 
 
243
        $this->assertNull($server->getWsdl());
 
244
        $server->setWsdl(dirname(__FILE__).'/_files/wsdl_example.wsdl');
 
245
        $this->assertEquals(dirname(__FILE__).'/_files/wsdl_example.wsdl', $server->getWsdl());
 
246
        try {
 
247
            $server->setWsdl(dirname(__FILE__).'/_files/bogus.wsdl');
 
248
            $this->fail('Invalid WSDL URI or PATH should fail');
 
249
        } catch (Exception $e)  {
 
250
            // success
 
251
        }
 
252
    }
 
253
 
 
254
    public function testGetWsdl()
 
255
    {
 
256
        $server = new Zend_Soap_Server();
 
257
 
 
258
        $this->assertNull($server->getWsdl());
 
259
        $server->setWsdl(dirname(__FILE__).'/_files/wsdl_example.wsdl');
 
260
        $this->assertEquals(dirname(__FILE__).'/_files/wsdl_example.wsdl', $server->getWsdl());
 
261
    }
 
262
 
 
263
    public function testAddFunction()
 
264
    {
 
265
        $server = new Zend_Soap_Server();
 
266
 
 
267
        // Correct function should pass
 
268
        $server->addFunction('Zend_Soap_Server_TestFunc1');
 
269
 
 
270
        // Array of correct functions should pass
 
271
        $functions = array('Zend_Soap_Server_TestFunc2',
 
272
                           'Zend_Soap_Server_TestFunc3',
 
273
                           'Zend_Soap_Server_TestFunc4');
 
274
        $server->addFunction($functions);
 
275
 
 
276
        $this->assertEquals(
 
277
            array_merge(array('Zend_Soap_Server_TestFunc1'), $functions),
 
278
            $server->getFunctions()
 
279
        );
 
280
    }
 
281
 
 
282
    public function testAddBogusFunctionAsInteger()
 
283
    {
 
284
        $server = new Zend_Soap_Server();
 
285
        try {
 
286
            $server->addFunction(126);
 
287
            $this->fail('Invalid value should fail');
 
288
        } catch (Zend_Soap_Server_Exception $e)  {
 
289
            // success
 
290
        }
 
291
    }
 
292
 
 
293
    public function testAddBogusFunctionsAsString()
 
294
    {
 
295
        $server = new Zend_Soap_Server();
 
296
 
 
297
        try {
 
298
                $server->addFunction('bogus_function');
 
299
            $this->fail('Invalid function should fail.');
 
300
        } catch (Zend_Soap_Server_Exception $e)  {
 
301
            // success
 
302
        }
 
303
    }
 
304
 
 
305
    public function testAddBogusFunctionsAsArray()
 
306
    {
 
307
        $server = new Zend_Soap_Server();
 
308
 
 
309
        try {
 
310
                $functions = array('Zend_Soap_Server_TestFunc5',
 
311
                                    'bogus_function',
 
312
                                    'Zend_Soap_Server_TestFunc6');
 
313
                $server->addFunction($functions);
 
314
            $this->fail('Invalid function within a set of functions should fail');
 
315
        } catch (Zend_Soap_Server_Exception $e)  {
 
316
            // success
 
317
        }
 
318
    }
 
319
 
 
320
    public function testAddAllFunctionsSoapConstant()
 
321
    {
 
322
        $server = new Zend_Soap_Server();
 
323
 
 
324
        // SOAP_FUNCTIONS_ALL as a value should pass
 
325
        $server->addFunction(SOAP_FUNCTIONS_ALL);
 
326
        $server->addFunction('substr');
 
327
        $this->assertEquals(array(SOAP_FUNCTIONS_ALL), $server->getFunctions());
 
328
    }
 
329
 
 
330
    public function testSetClass()
 
331
    {
 
332
        $server = new Zend_Soap_Server();
 
333
 
 
334
        // Correct class name should pass
 
335
        try {
 
336
            $server->setClass('Zend_Soap_Server_TestClass');
 
337
        } catch(Exception $e) {
 
338
            $this->fail("Setting a correct class name should not fail setClass()");
 
339
        }
 
340
    }
 
341
 
 
342
    public function testSetClassTwiceThrowsException()
 
343
    {
 
344
        $server = new Zend_Soap_Server();
 
345
 
 
346
        // Correct class name should pass
 
347
        try {
 
348
            $server->setClass('Zend_Soap_Server_TestClass');
 
349
            $server->setClass('Zend_Soap_Server_TestClass');
 
350
            $this->fail();
 
351
        } catch(Zend_Soap_Server_Exception $e) {
 
352
            $this->assertEquals('A class has already been registered with this soap server instance', $e->getMessage());
 
353
        }
 
354
    }
 
355
 
 
356
    public function testSetClassWithArguments()
 
357
    {
 
358
        $server = new Zend_Soap_Server();
 
359
 
 
360
        // Correct class name should pass
 
361
        try {
 
362
            $server->setClass('Zend_Soap_Server_TestClass', 1, 2, 3, 4);
 
363
        } catch(Exception $e) {
 
364
            $this->fail("Setting a correct class name should not fail setClass()");
 
365
        }
 
366
    }
 
367
 
 
368
    public function testSetBogusClassWithIntegerName()
 
369
    {
 
370
        $server = new Zend_Soap_Server();
 
371
 
 
372
        try {
 
373
            $server->setClass(465);
 
374
            $this->fail('Non-string value should fail');
 
375
        } catch (Exception $e)  {
 
376
            // success
 
377
        }
 
378
    }
 
379
 
 
380
    public function testSetBogusClassWithUnknownClassName()
 
381
    {
 
382
        $server = new Zend_Soap_Server();
 
383
 
 
384
        try {
 
385
            $server->setClass('Zend_Soap_Server_Test_BogusClass');
 
386
            $this->fail('Invalid class should fail');
 
387
        } catch (Exception $e)  {
 
388
            // success
 
389
        }
 
390
    }
 
391
 
 
392
    /**
 
393
     * @group ZF-4366
 
394
     */
 
395
    public function testSetObject()
 
396
    {
 
397
        $server = new Zend_Soap_Server();
 
398
 
 
399
        try {
 
400
            $server->setObject(465);
 
401
            $this->fail('Non-object value should fail');
 
402
        } catch (Exception $e)  {
 
403
            // success
 
404
        }
 
405
 
 
406
        try {
 
407
            $int = 1;
 
408
            $server->setObject($int);
 
409
            $this->fail('Invalid argument should fail');
 
410
        } catch (Exception $e)  {
 
411
            // success
 
412
        }
 
413
 
 
414
        // Correct class name should pass
 
415
        $server->setObject(new Zend_Soap_Server_TestClass());
 
416
 
 
417
        try {
 
418
            $server->setObject(new Zend_Soap_Server_TestClass());
 
419
            $this->fail('setClass() should pass only once');
 
420
        } catch (Exception $e)  {
 
421
            // success
 
422
        }
 
423
    }
 
424
 
 
425
    public function testGetFunctions()
 
426
    {
 
427
        $server = new Zend_Soap_Server();
 
428
 
 
429
        $server->addFunction('Zend_Soap_Server_TestFunc1');
 
430
 
 
431
        $functions  =  array('Zend_Soap_Server_TestFunc2',
 
432
                             'Zend_Soap_Server_TestFunc3',
 
433
                             'Zend_Soap_Server_TestFunc4');
 
434
        $server->addFunction($functions);
 
435
 
 
436
        $functions  =  array('Zend_Soap_Server_TestFunc3',
 
437
                             'Zend_Soap_Server_TestFunc5',
 
438
                             'Zend_Soap_Server_TestFunc6');
 
439
        $server->addFunction($functions);
 
440
 
 
441
        $allAddedFunctions = array(
 
442
            'Zend_Soap_Server_TestFunc1',
 
443
            'Zend_Soap_Server_TestFunc2',
 
444
            'Zend_Soap_Server_TestFunc3',
 
445
            'Zend_Soap_Server_TestFunc4',
 
446
            'Zend_Soap_Server_TestFunc5',
 
447
                        'Zend_Soap_Server_TestFunc6'
 
448
        );
 
449
        $this->assertTrue($server->getFunctions() == $allAddedFunctions);
 
450
    }
 
451
 
 
452
    public function testGetFunctionsWithClassAttached()
 
453
    {
 
454
        $server = new Zend_Soap_Server();
 
455
        $server->setClass('Zend_Soap_Server_TestClass');
 
456
 
 
457
        $this->assertEquals(
 
458
            array('testFunc1', 'testFunc2', 'testFunc3', 'testFunc4', 'testFunc5'),
 
459
            $server->getFunctions()
 
460
        );
 
461
    }
 
462
 
 
463
    public function testGetFunctionsWithObjectAttached()
 
464
    {
 
465
        $server = new Zend_Soap_Server();
 
466
        $server->setObject(new Zend_Soap_Server_TestClass());
 
467
 
 
468
        $this->assertEquals(
 
469
            array('testFunc1', 'testFunc2', 'testFunc3', 'testFunc4', 'testFunc5'),
 
470
            $server->getFunctions()
 
471
        );
 
472
    }
 
473
 
 
474
    public function testSetPersistence()
 
475
    {
 
476
        $server = new Zend_Soap_Server();
 
477
 
 
478
        $this->assertNull($server->getPersistence());
 
479
        $server->setPersistence(SOAP_PERSISTENCE_SESSION);
 
480
        $this->assertEquals(SOAP_PERSISTENCE_SESSION, $server->getPersistence());
 
481
        try {
 
482
            $server->setSoapVersion('bogus');
 
483
            $this->fail('Invalid soap versions should fail');
 
484
        } catch (Exception $e)  {
 
485
            // success
 
486
        }
 
487
 
 
488
        $server->setPersistence(SOAP_PERSISTENCE_REQUEST);
 
489
        $this->assertEquals(SOAP_PERSISTENCE_REQUEST, $server->getPersistence());
 
490
    }
 
491
 
 
492
    public function testSetUnknownPersistenceStateThrowsException()
 
493
    {
 
494
        $server = new Zend_Soap_Server();
 
495
 
 
496
        try {
 
497
            $server->setPersistence('bogus');
 
498
            $this->fail();
 
499
        } catch(Zend_Soap_Server_Exception $e) {
 
500
            
 
501
        }
 
502
    }
 
503
 
 
504
    public function testGetPersistence()
 
505
    {
 
506
        $server = new Zend_Soap_Server();
 
507
 
 
508
        $this->assertNull($server->getPersistence());
 
509
        $server->setPersistence(SOAP_PERSISTENCE_SESSION);
 
510
        $this->assertEquals(SOAP_PERSISTENCE_SESSION, $server->getPersistence());
 
511
    }
 
512
 
 
513
    public function testGetLastRequest()
 
514
    {
 
515
        $server = new Zend_Soap_Server();
 
516
        $server->setOptions(array('location'=>'test://', 'uri'=>'http://framework.zend.com'));
 
517
        $server->setReturnResponse(true);
 
518
 
 
519
        $server->setClass('Zend_Soap_Server_TestClass');
 
520
 
 
521
        $request =
 
522
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
523
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
524
                             . 'xmlns:ns1="http://framework.zend.com" '
 
525
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
526
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
527
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
528
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
529
          .     '<SOAP-ENV:Body>'
 
530
          .         '<ns1:testFunc2>'
 
531
          .             '<param0 xsi:type="xsd:string">World</param0>'
 
532
          .         '</ns1:testFunc2>'
 
533
          .     '</SOAP-ENV:Body>'
 
534
          . '</SOAP-ENV:Envelope>' . "\n";
 
535
 
 
536
        $response = $server->handle($request);
 
537
 
 
538
        $this->assertEquals($request, $server->getLastRequest());
 
539
    }
 
540
 
 
541
    public function testSetReturnResponse()
 
542
    {
 
543
        $server = new Zend_Soap_Server();
 
544
 
 
545
        $this->assertFalse($server->getReturnResponse());
 
546
 
 
547
        $server->setReturnResponse(true);
 
548
        $this->assertTrue($server->getReturnResponse());
 
549
 
 
550
        $server->setReturnResponse(false);
 
551
        $this->assertFalse($server->getReturnResponse());
 
552
    }
 
553
 
 
554
    public function testGetReturnResponse()
 
555
    {
 
556
        $server = new Zend_Soap_Server();
 
557
 
 
558
        $this->assertFalse($server->getReturnResponse());
 
559
 
 
560
        $server->setReturnResponse(true);
 
561
        $this->assertTrue($server->getReturnResponse());
 
562
    }
 
563
 
 
564
    public function testGetLastResponse()
 
565
    {
 
566
        $server = new Zend_Soap_Server();
 
567
        $server->setOptions(array('location'=>'test://', 'uri'=>'http://framework.zend.com'));
 
568
        $server->setReturnResponse(true);
 
569
 
 
570
        $server->setClass('Zend_Soap_Server_TestClass');
 
571
 
 
572
        $request =
 
573
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
574
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
575
                             . 'xmlns:ns1="http://framework.zend.com" '
 
576
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
577
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
578
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
579
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
580
          .     '<SOAP-ENV:Body>'
 
581
          .         '<ns1:testFunc2>'
 
582
          .             '<param0 xsi:type="xsd:string">World</param0>'
 
583
          .         '</ns1:testFunc2>'
 
584
          .     '</SOAP-ENV:Body>'
 
585
          . '</SOAP-ENV:Envelope>' . "\n";
 
586
 
 
587
        $expectedResponse =
 
588
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
589
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
590
                             . 'xmlns:ns1="http://framework.zend.com" '
 
591
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
592
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
593
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
594
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
595
          .     '<SOAP-ENV:Body>'
 
596
          .         '<ns1:testFunc2Response>'
 
597
          .             '<return xsi:type="xsd:string">Hello World!</return>'
 
598
          .         '</ns1:testFunc2Response>'
 
599
          .     '</SOAP-ENV:Body>'
 
600
          . '</SOAP-ENV:Envelope>' . "\n";
 
601
 
 
602
        $server->handle($request);
 
603
 
 
604
        $this->assertEquals($expectedResponse, $server->getLastResponse());
 
605
    }
 
606
 
 
607
    public function testHandle()
 
608
    {
 
609
        $server = new Zend_Soap_Server();
 
610
        $server->setOptions(array('location'=>'test://', 'uri'=>'http://framework.zend.com'));
 
611
 
 
612
        $server->setClass('Zend_Soap_Server_TestClass');
 
613
 
 
614
        $localClient = new Zend_Soap_Server_TestLocalSoapClient($server,
 
615
                                                                null,
 
616
                                                                array('location'=>'test://',
 
617
                                                                      'uri'=>'http://framework.zend.com'));
 
618
 
 
619
        // Local SOAP client call automatically invokes handle method of the provided SOAP server
 
620
        $this->assertEquals('Hello World!', $localClient->testFunc2('World'));
 
621
 
 
622
 
 
623
        $request =
 
624
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
625
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
626
                             . 'xmlns:ns1="http://framework.zend.com" '
 
627
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
628
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
629
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
630
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
631
          .     '<SOAP-ENV:Body>'
 
632
          .         '<ns1:testFunc2>'
 
633
          .             '<param0 xsi:type="xsd:string">World</param0>'
 
634
          .         '</ns1:testFunc2>'
 
635
          .     '</SOAP-ENV:Body>'
 
636
          . '</SOAP-ENV:Envelope>' . "\n";
 
637
 
 
638
        $expectedResponse =
 
639
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
640
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
641
                             . 'xmlns:ns1="http://framework.zend.com" '
 
642
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
643
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
644
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
645
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
646
          .     '<SOAP-ENV:Body>'
 
647
          .         '<ns1:testFunc2Response>'
 
648
          .             '<return xsi:type="xsd:string">Hello World!</return>'
 
649
          .         '</ns1:testFunc2Response>'
 
650
          .     '</SOAP-ENV:Body>'
 
651
          . '</SOAP-ENV:Envelope>' . "\n";
 
652
 
 
653
        $server1 = new Zend_Soap_Server();
 
654
        $server1->setOptions(array('location'=>'test://', 'uri'=>'http://framework.zend.com'));
 
655
 
 
656
        $server1->setClass('Zend_Soap_Server_TestClass');
 
657
        $server1->setReturnResponse(true);
 
658
 
 
659
        $this->assertEquals($expectedResponse, $server1->handle($request));
 
660
    }
 
661
 
 
662
    /**
 
663
     * @todo Implement testRegisterFaultException().
 
664
     */
 
665
    public function testRegisterFaultException()
 
666
    {
 
667
        $server = new Zend_Soap_Server();
 
668
 
 
669
        $server->registerFaultException("Zend_Soap_Server_Exception");
 
670
        $server->registerFaultException(array("OutOfBoundsException", "BogusException"));
 
671
 
 
672
        $this->assertEquals(array(
 
673
            'Zend_Soap_Server_Exception',
 
674
            'OutOfBoundsException',
 
675
            'BogusException',
 
676
        ), $server->getFaultExceptions());
 
677
    }
 
678
 
 
679
    /**
 
680
     * @todo Implement testDeregisterFaultException().
 
681
     */
 
682
    public function testDeregisterFaultException()
 
683
    {
 
684
        $server = new Zend_Soap_Server();
 
685
 
 
686
        $server->registerFaultException(array("OutOfBoundsException", "BogusException"));
 
687
        $ret = $server->deregisterFaultException("BogusException");
 
688
        $this->assertTrue($ret);
 
689
 
 
690
        $this->assertEquals(array(
 
691
            'OutOfBoundsException',
 
692
        ), $server->getFaultExceptions());
 
693
 
 
694
        $ret = $server->deregisterFaultException("NonRegisteredException");
 
695
        $this->assertFalse($ret);
 
696
    }
 
697
 
 
698
    /**
 
699
     * @todo Implement testGetFaultExceptions().
 
700
     */
 
701
    public function testGetFaultExceptions()
 
702
    {
 
703
        $server = new Zend_Soap_Server();
 
704
 
 
705
        $this->assertEquals(array(), $server->getFaultExceptions());
 
706
        $server->registerFaultException("Exception");
 
707
        $this->assertEquals(array("Exception"), $server->getFaultExceptions());
 
708
    }
 
709
 
 
710
    public function testFaultWithTextMessage()
 
711
    {
 
712
        $server = new Zend_Soap_Server();
 
713
        $fault = $server->fault("Faultmessage!");
 
714
 
 
715
        $this->assertTrue($fault instanceof SOAPFault);
 
716
        $this->assertContains("Faultmessage!", $fault->getMessage());
 
717
    }
 
718
 
 
719
    public function testFaultWithUnregisteredException()
 
720
    {
 
721
        $server = new Zend_Soap_Server();
 
722
        $fault = $server->fault(new Exception("MyException"));
 
723
 
 
724
        $this->assertTrue($fault instanceof SOAPFault);
 
725
        $this->assertContains("Unknown error", $fault->getMessage());
 
726
        $this->assertNotContains("MyException", $fault->getMessage());
 
727
    }
 
728
 
 
729
    public function testFaultWithRegisteredException()
 
730
    {
 
731
        $server = new Zend_Soap_Server();
 
732
        $server->registerFaultException("Exception");
 
733
        $fault = $server->fault(new Exception("MyException"));
 
734
 
 
735
        $this->assertTrue($fault instanceof SOAPFault);
 
736
        $this->assertNotContains("Unknown error", $fault->getMessage());
 
737
        $this->assertContains("MyException", $fault->getMessage());
 
738
    }
 
739
 
 
740
    public function testFautlWithBogusInput()
 
741
    {
 
742
        $server = new Zend_Soap_Server();
 
743
        $fault = $server->fault(array("Here", "There", "Bogus"));
 
744
 
 
745
        $this->assertContains("Unknown error", $fault->getMessage());
 
746
    }
 
747
 
 
748
    /**
 
749
     * @group ZF-3958
 
750
     */
 
751
    public function testFaultWithIntegerFailureCodeDoesNotBreakClassSoapFault()
 
752
    {
 
753
        $server = new Zend_Soap_Server();
 
754
        $fault = $server->fault("Faultmessage!", 5000);
 
755
 
 
756
        $this->assertTrue($fault instanceof SOAPFault);
 
757
    }
 
758
 
 
759
    /**
 
760
     * @todo Implement testHandlePhpErrors().
 
761
     */
 
762
    public function testHandlePhpErrors()
 
763
    {
 
764
        $server = new Zend_Soap_Server();
 
765
 
 
766
        // Remove the following line when you implement this test.
 
767
        $this->markTestIncomplete(
 
768
          "This test has not been implemented yet."
 
769
        );
 
770
    }
 
771
 
 
772
    public function testLoadFunctionsIsNotImplemented()
 
773
    {
 
774
        $server = new Zend_Soap_Server();
 
775
 
 
776
        try {
 
777
            $server->loadFunctions("bogus");
 
778
            $this->fail();
 
779
        } catch(Zend_Soap_Server_Exception $e) {
 
780
            
 
781
        }
 
782
    }
 
783
 
 
784
    public function testErrorHandlingOfSoapServerChangesToThrowingSoapFaultWhenInHandleMode()
 
785
    {
 
786
        $server = new Zend_Soap_Server();
 
787
        $server->setOptions(array('location'=>'test://', 'uri'=>'http://framework.zend.com'));
 
788
        $server->setReturnResponse(true);
 
789
 
 
790
        // Requesting Method with enforced parameter without it.
 
791
        $request =
 
792
            '<?xml version="1.0" encoding="UTF-8"?>' . "\n"
 
793
          . '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" '
 
794
                             . 'xmlns:ns1="http://framework.zend.com" '
 
795
                             . 'xmlns:xsd="http://www.w3.org/2001/XMLSchema" '
 
796
                             . 'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
 
797
                             . 'xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" '
 
798
                             . 'SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">'
 
799
          .     '<SOAP-ENV:Body>'
 
800
          .         '<ns1:testFunc5 />'
 
801
          .     '</SOAP-ENV:Body>'
 
802
          . '</SOAP-ENV:Envelope>' . "\n";
 
803
 
 
804
        $server->setClass('Zend_Soap_Server_TestClass');
 
805
        $response = $server->handle($request);
 
806
 
 
807
        $this->assertContains(
 
808
            '<SOAP-ENV:Fault><faultcode>Receiver</faultcode><faultstring>Test Message</faultstring></SOAP-ENV:Fault>',
 
809
            $response
 
810
        );
 
811
    }
 
812
 
 
813
    /**
 
814
     * @group ZF-5597
 
815
     */
 
816
    public function testServerAcceptsZendConfigObject()
 
817
    {
 
818
        $options = array('soap_version' => SOAP_1_1,
 
819
                         'actor' => 'http://framework.zend.com/Zend_Soap_ServerTest.php',
 
820
                         'classmap' => array('TestData1' => 'Zend_Soap_Server_TestData1',
 
821
                                             'TestData2' => 'Zend_Soap_Server_TestData2',),
 
822
                         'encoding' => 'ISO-8859-1',
 
823
                         'uri' => 'http://framework.zend.com/Zend_Soap_ServerTest.php'
 
824
                        );
 
825
        $config = new Zend_Config($options);
 
826
 
 
827
        $server = new Zend_Soap_Server();
 
828
        $server->setOptions($config);
 
829
        $this->assertEquals($options, $server->getOptions());
 
830
    }
 
831
 
 
832
    /**
 
833
     * @group ZF-5300
 
834
     */
 
835
    public function testSetAndGetFeatures()
 
836
    {
 
837
        $server = new Zend_Soap_Server();
 
838
        $this->assertNull($server->getSoapFeatures());
 
839
        $server->setSoapFeatures(100);
 
840
        $this->assertEquals(100, $server->getSoapFeatures());
 
841
        $options = $server->getOptions();
 
842
        $this->assertTrue(isset($options['features']));
 
843
        $this->assertEquals(100, $options['features']);
 
844
    }
 
845
 
 
846
    /**
 
847
     * @group ZF-5300
 
848
     */
 
849
    public function testSetAndGetWsdlCache()
 
850
    {
 
851
        $server = new Zend_Soap_Server();
 
852
        $this->assertNull($server->getWsdlCache());
 
853
        $server->setWsdlCache(100);
 
854
        $this->assertEquals(100, $server->getWsdlCache());
 
855
        $options = $server->getOptions();
 
856
        $this->assertTrue(isset($options['cache_wsdl']));
 
857
        $this->assertEquals(100, $options['cache_wsdl']);
 
858
    }
 
859
}
 
860
 
 
861
 
 
862
if (extension_loaded('soap')) {
 
863
 
 
864
/** Local SOAP client */
 
865
class Zend_Soap_Server_TestLocalSoapClient extends SoapClient {
 
866
        /**
 
867
         * Server object
 
868
         *
 
869
         * @var Zend_Soap_Server
 
870
         */
 
871
        public $server;
 
872
 
 
873
        /**
 
874
         * Local client constructor
 
875
         *
 
876
         * @param Zend_Soap_Server $server
 
877
         * @param string $wsdl
 
878
         * @param array $options
 
879
         */
 
880
    function __construct(Zend_Soap_Server $server, $wsdl, $options) {
 
881
        $this->server = $server;
 
882
        parent::__construct($wsdl, $options);
 
883
    }
 
884
 
 
885
    function __doRequest($request, $location, $action, $version) {
 
886
        ob_start();
 
887
        $this->server->handle($request);
 
888
        $response = ob_get_contents();
 
889
        ob_end_clean();
 
890
 
 
891
        return $response;
 
892
    }
 
893
}
 
894
 
 
895
}
 
896
 
 
897
 
 
898
/** Test Class */
 
899
class Zend_Soap_Server_TestClass {
 
900
    /**
 
901
     * Test Function 1
 
902
     *
 
903
     * @return string
 
904
     */
 
905
    function testFunc1()
 
906
    {
 
907
        return "Hello World";
 
908
    }
 
909
 
 
910
    /**
 
911
     * Test Function 2
 
912
     *
 
913
     * @param string $who Some Arg
 
914
     * @return string
 
915
     */
 
916
    function testFunc2($who)
 
917
    {
 
918
        return "Hello $who!";
 
919
    }
 
920
 
 
921
    /**
 
922
     * Test Function 3
 
923
     *
 
924
     * @param string $who Some Arg
 
925
     * @param int $when Some
 
926
     * @return string
 
927
     */
 
928
    function testFunc3($who, $when)
 
929
    {
 
930
        return "Hello $who, How are you $when";
 
931
    }
 
932
 
 
933
    /**
 
934
     * Test Function 4
 
935
     *
 
936
     * @return string
 
937
     */
 
938
    static function testFunc4()
 
939
    {
 
940
        return "I'm Static!";
 
941
    }
 
942
 
 
943
    /**
 
944
     * Test Function 5 raises a user error
 
945
     *
 
946
     * @return void
 
947
     */
 
948
    function testFunc5()
 
949
    {
 
950
        trigger_error("Test Message", E_USER_ERROR);
 
951
    }
 
952
}
 
953
 
 
954
 
 
955
/** Test class 2 */
 
956
class Zend_Soap_Server_TestData1 {
 
957
    /**
 
958
     * Property1
 
959
     *
 
960
     * @var string
 
961
     */
 
962
     public $property1;
 
963
 
 
964
    /**
 
965
     * Property2
 
966
     *
 
967
     * @var float
 
968
     */
 
969
     public $property2;
 
970
}
 
971
 
 
972
/** Test class 2 */
 
973
class Zend_Soap_Server_TestData2 {
 
974
    /**
 
975
     * Property1
 
976
     *
 
977
     * @var integer
 
978
     */
 
979
     public $property1;
 
980
 
 
981
    /**
 
982
     * Property1
 
983
     *
 
984
     * @var float
 
985
     */
 
986
     public $property2;
 
987
}
 
988
 
 
989
 
 
990
/* Test Functions */
 
991
 
 
992
/**
 
993
 * Test Function
 
994
 *
 
995
 * @param string $arg
 
996
 * @return string
 
997
 */
 
998
function Zend_Soap_Server_TestFunc1($who)
 
999
{
 
1000
    return "Hello $who";
 
1001
}
 
1002
 
 
1003
/**
 
1004
 * Test Function 2
 
1005
 */
 
1006
function Zend_Soap_Server_TestFunc2()
 
1007
{
 
1008
    return "Hello World";
 
1009
}
 
1010
 
 
1011
/**
 
1012
 * Return false
 
1013
 *
 
1014
 * @return bool
 
1015
 */
 
1016
function Zend_Soap_Server_TestFunc3()
 
1017
{
 
1018
    return false;
 
1019
}
 
1020
 
 
1021
/**
 
1022
 * Return true
 
1023
 *
 
1024
 * @return bool
 
1025
 */
 
1026
function Zend_Soap_Server_TestFunc4()
 
1027
{
 
1028
    return true;
 
1029
}
 
1030
 
 
1031
/**
 
1032
 * Return integer
 
1033
 *
 
1034
 * @return int
 
1035
 */
 
1036
function Zend_Soap_Server_TestFunc5()
 
1037
{
 
1038
    return 123;
 
1039
}
 
1040
 
 
1041
/**
 
1042
 * Return string
 
1043
 *
 
1044
 * @return string
 
1045
 */
 
1046
function Zend_Soap_Server_TestFunc6()
 
1047
{
 
1048
    return "string";
 
1049
}
 
 
b'\\ No newline at end of file'