PageRenderTime 59ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 0ms

/cakesocial.local/app/vendors/zend/tests/Zend/Rest/ServerTest.php

https://github.com/miamiruby/cakestuff
PHP | 822 lines | 581 code | 90 blank | 151 comment | 5 complexity | d40984bc51cebcc129d26ef2ee2612e0 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, LGPL-2.0, MIT
  1. <?php
  2. /**
  3. * @package Zend_Rest
  4. * @subpackage UnitTests
  5. */
  6. // Call Zend_Rest_ServerTest::main() if this source file is executed directly.
  7. if (!defined("PHPUnit_MAIN_METHOD")) {
  8. define("PHPUnit_MAIN_METHOD", "Zend_Rest_ServerTest::main");
  9. }
  10. require_once dirname(__FILE__) . '/../../TestHelper.php';
  11. /**
  12. * Zend_Rest_Server
  13. */
  14. require_once 'Zend/Rest/Server.php';
  15. /**
  16. * Test cases for Zend_Rest_Server
  17. *
  18. * @package Zend_Rest
  19. * @subpackage UnitTests
  20. */
  21. class Zend_Rest_ServerTest extends PHPUnit_Framework_TestCase
  22. {
  23. /**
  24. * Runs the test methods of this class.
  25. *
  26. * @return void
  27. */
  28. public static function main()
  29. {
  30. require_once "PHPUnit/TextUI/TestRunner.php";
  31. $suite = new PHPUnit_Framework_TestSuite("Zend_Rest_ServerTest");
  32. $result = PHPUnit_TextUI_TestRunner::run($suite);
  33. }
  34. public function setUp()
  35. {
  36. if (isset($this->request)) {
  37. $_REQUEST = $this->request;
  38. } else {
  39. $this->request = $_REQUEST;
  40. }
  41. }
  42. public function testAddFunctionSimple()
  43. {
  44. $server = new Zend_Rest_Server();
  45. $server->addFunction('Zend_Rest_Server_TestFunc');
  46. $funcs = $server->getFunctions();
  47. $this->assertTrue(isset($funcs['Zend_Rest_Server_TestFunc']), "Function not registered.");
  48. }
  49. public function testSetClass()
  50. {
  51. $server = new Zend_Rest_Server();
  52. $server->setClass('Zend_Rest_Server_Test');
  53. $funcs = $server->getFunctions();
  54. $this->assertTrue(isset($funcs['testFunc']), "Class Not Registered. testFunc not found");
  55. $this->assertTrue(isset($funcs['testFunc2']), "Class Not Registered. testFunc2 not found");
  56. $this->assertTrue(isset($funcs['testFunc3']), "Class Not Registered. testFunc3 not found");
  57. }
  58. public function testHandleNamedArgFunction()
  59. {
  60. $server = new Zend_Rest_Server();
  61. $server->addFunction('Zend_Rest_Server_TestFunc');
  62. ob_start();
  63. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc', 'who' => 'Davey'));
  64. $result = ob_get_clean();
  65. $this->assertContains('<Zend_Rest_Server_TestFunc generator="zend" version="1.0"><response>Hello Davey</response><status>success</status></Zend_Rest_Server_TestFunc>', $result, "Bad Result");
  66. }
  67. public function testHandleFunctionNoArgs()
  68. {
  69. $server = new Zend_Rest_Server();
  70. $server->addFunction('Zend_Rest_Server_TestFunc2');
  71. ob_start();
  72. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc2'));
  73. $result = ob_get_clean();
  74. $this->assertContains('<Zend_Rest_Server_TestFunc2 generator="zend" version="1.0"><response>Hello World</response><status>success</status></Zend_Rest_Server_TestFunc2>', $result, "Bad Result");
  75. }
  76. public function testHandleFunctionNoArgsRaisesFaultResponse()
  77. {
  78. $server = new Zend_Rest_Server();
  79. $server->returnResponse(true);
  80. $server->addFunction('Zend_Rest_Server_TestFunc');
  81. $result = $server->handle(array('method' => 'Zend_Rest_Server_TestFunc'));
  82. $this->assertContains('failed', $result);
  83. }
  84. public function testHandleFunctionNoArgsUsingRequest()
  85. {
  86. $_REQUEST = array(
  87. 'method' => 'Zend_Rest_Server_TestFunc2'
  88. );
  89. $server = new Zend_Rest_Server();
  90. $server->addFunction('Zend_Rest_Server_TestFunc2');
  91. ob_start();
  92. $server->handle();
  93. $result = ob_get_clean();
  94. $this->assertContains('<Zend_Rest_Server_TestFunc2 generator="zend" version="1.0"><response>Hello World</response><status>success</status></Zend_Rest_Server_TestFunc2>', $result, "Bad Result");
  95. }
  96. public function testHandleAnonymousArgFunction()
  97. {
  98. $server = new Zend_Rest_Server();
  99. $server->addFunction('Zend_Rest_Server_TestFunc');
  100. ob_start();
  101. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc', 'arg1' => 'Davey'));
  102. $result = ob_get_clean();
  103. $this->assertContains('<Zend_Rest_Server_TestFunc generator="zend" version="1.0"><response>Hello Davey</response><status>success</status></Zend_Rest_Server_TestFunc>', $result, "Bad Result");
  104. }
  105. public function testHandleMultipleFunction()
  106. {
  107. $server = new Zend_Rest_Server();
  108. $server->addFunction('Zend_Rest_Server_TestFunc2');
  109. $server->addFunction('Zend_Rest_Server_TestFunc');
  110. ob_start();
  111. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc2'));
  112. $result = ob_get_clean();
  113. $this->assertContains('<Zend_Rest_Server_TestFunc2 generator="zend" version="1.0"><response>Hello World</response><status>success</status></Zend_Rest_Server_TestFunc2>', $result, "Bad Result");
  114. ob_start();
  115. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc', 'arg1' => 'Davey'));
  116. $result = ob_get_clean();
  117. $this->assertContains('<Zend_Rest_Server_TestFunc generator="zend" version="1.0"><response>Hello Davey</response><status>success</status></Zend_Rest_Server_TestFunc>', $result, "Bad Result");
  118. }
  119. public function testHandleMethodNoArgs()
  120. {
  121. $server = new Zend_Rest_Server();
  122. $server->setClass('Zend_Rest_Server_Test');
  123. ob_start();
  124. $server->handle(array('method' => 'testFunc'));
  125. $result = ob_get_clean();
  126. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc><response>Hello World</response><status>success</status></testFunc></Zend_Rest_Server_Test>', $result, 'Bad Result');
  127. }
  128. public function testHandleMethodOfClassWithConstructor()
  129. {
  130. $server = new Zend_Rest_Server();
  131. $server->setClass('Zend_Rest_Server_Test2', '', array('testing args'));
  132. ob_start();
  133. $server->handle(array('method' => 'test2Func1'));
  134. $result = ob_get_clean();
  135. $this->assertContains("testing args", $result, "Bad Result");
  136. }
  137. public function testHandleAnonymousArgMethod()
  138. {
  139. $server = new Zend_Rest_Server();
  140. $server->setClass('Zend_Rest_Server_Test');
  141. ob_start();
  142. $server->handle(array('method' => 'testFunc2', 'arg1' => "Davey"));
  143. $result = ob_get_clean();
  144. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc2><response>Hello Davey</response><status>success</status></testFunc2></Zend_Rest_Server_Test>', $result, 'Bad Result');
  145. }
  146. public function testHandleNamedArgMethod()
  147. {
  148. $server = new Zend_Rest_Server();
  149. $server->setClass('Zend_Rest_Server_Test');
  150. ob_start();
  151. $server->handle(array('method' => 'testFunc3', 'who' => "Davey", 'when' => 'today'));
  152. $result = ob_get_clean();
  153. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc3><response>Hello Davey, How are you today</response><status>success</status></testFunc3></Zend_Rest_Server_Test>', $result, 'Bad Result');
  154. }
  155. public function testHandleStaticNoArgs()
  156. {
  157. $server = new Zend_Rest_Server();
  158. $server->setClass('Zend_Rest_Server_Test');
  159. ob_start();
  160. $server->handle(array('method' => 'testFunc4'));
  161. $result = ob_get_clean();
  162. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc4><response>Hello World</response><status>success</status></testFunc4></Zend_Rest_Server_Test>', $result, var_export($result, 1));
  163. }
  164. public function testHandleAnonymousArgStatic()
  165. {
  166. $server = new Zend_Rest_Server();
  167. $server->setClass('Zend_Rest_Server_Test');
  168. ob_start();
  169. $server->handle(array('method' => 'testFunc5', 'arg1' => "Davey"));
  170. $result = ob_get_clean();
  171. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc5><response>Hello Davey</response><status>success</status></testFunc5></Zend_Rest_Server_Test>', $result, 'Bad Result');
  172. }
  173. public function testHandleNamedArgStatic()
  174. {
  175. $server = new Zend_Rest_Server();
  176. $server->setClass('Zend_Rest_Server_Test');
  177. ob_start();
  178. $server->handle(array('method' => 'testFunc6', 'who' => "Davey", 'when' => 'today'));
  179. $result = ob_get_clean();
  180. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc6><response>Hello Davey, How are you today</response><status>success</status></testFunc6></Zend_Rest_Server_Test>', $result, 'Bad Result');
  181. }
  182. public function testHandleMultipleAnonymousArgs()
  183. {
  184. $server = new Zend_Rest_Server();
  185. $server->addFunction('Zend_Rest_Server_TestFunc9');
  186. ob_start();
  187. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc9', 'arg1' => "Hello", 'arg2' => "Davey"));
  188. $result = ob_get_clean();
  189. $this->assertContains('<Zend_Rest_Server_TestFunc9 generator="zend" version="1.0"><response>Hello Davey</response><status>success</status></Zend_Rest_Server_TestFunc9>', $result, "Bad Result");
  190. }
  191. public function testHandleReturnFalse()
  192. {
  193. $server = new Zend_Rest_Server();
  194. $server->addFunction('Zend_Rest_Server_TestFunc3');
  195. ob_start();
  196. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc3'));
  197. $result = ob_get_clean();
  198. $this->assertContains('<Zend_Rest_Server_TestFunc3 generator="zend" version="1.0"><response>0</response><status>success</status></Zend_Rest_Server_TestFunc3>', $result, 'Bas Response');
  199. }
  200. public function testHandleReturnTrue()
  201. {
  202. $server = new Zend_Rest_Server();
  203. $server->addFunction('Zend_Rest_Server_TestFunc4');
  204. ob_start();
  205. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc4'));
  206. $result = ob_get_clean();
  207. $this->assertContains('<Zend_Rest_Server_TestFunc4 generator="zend" version="1.0"><response>1</response><status>success</status></Zend_Rest_Server_TestFunc4>', $result, 'Bas Response');
  208. }
  209. public function testHandleReturnInteger()
  210. {
  211. $server = new Zend_Rest_Server();
  212. $server->addFunction('Zend_Rest_Server_TestFunc5');
  213. ob_start();
  214. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc5'));
  215. $result = ob_get_clean();
  216. $this->assertContains('<Zend_Rest_Server_TestFunc5 generator="zend" version="1.0"><response>123</response><status>success</status></Zend_Rest_Server_TestFunc5>', $result, 'Bas Response');
  217. }
  218. public function testHandleReturnString()
  219. {
  220. $server = new Zend_Rest_Server();
  221. $server->addFunction('Zend_Rest_Server_TestFunc6');
  222. ob_start();
  223. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc6'));
  224. $result = ob_get_clean();
  225. $this->assertContains('<Zend_Rest_Server_TestFunc6 generator="zend" version="1.0"><response>string</response><status>success</status></Zend_Rest_Server_TestFunc6>', $result, 'Bas Response');
  226. }
  227. public function testHandleReturnArray()
  228. {
  229. $server = new Zend_Rest_Server();
  230. $server->addFunction('Zend_Rest_Server_TestFunc7');
  231. ob_start();
  232. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc7'));
  233. $result = ob_get_clean();
  234. $this->assertContains('<Zend_Rest_Server_TestFunc7 generator="zend" version="1.0"><foo>bar</foo><baz>1</baz><key_1>0</key_1><bat>123</bat><status>success</status></Zend_Rest_Server_TestFunc7>', $result, $result);
  235. }
  236. public function testHandleReturnNestedArray()
  237. {
  238. $server = new Zend_Rest_Server();
  239. $server->addFunction('Zend_Rest_Server_TestFunc12');
  240. ob_start();
  241. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc12'));
  242. $result = ob_get_clean();
  243. $this->assertContains('Zend_Rest_Server_TestFunc12', $result, $result);
  244. $this->assertContains('<foo><baz>1</baz>', $result, $result);
  245. $this->assertContains('<bat>123</bat></foo><bar>baz</bar>', $result, $result);
  246. $this->assertContains('</bar><status>success</status', $result, $result);
  247. }
  248. public function testHandleMethodReturnObject()
  249. {
  250. $server = new Zend_Rest_Server();
  251. $server->setClass('Zend_Rest_Server_Test2');
  252. ob_start();
  253. $server->handle(array('method' => 'test2Struct'));
  254. $result = ob_get_clean();
  255. $this->assertContains('<Zend_Rest_Server_Test2', $result, $result);
  256. $this->assertContains('<test2Struct', $result, $result);
  257. $this->assertContains('<foo><baz>1</baz>', $result, $result);
  258. $this->assertContains('<bat>123</bat></foo><bar>baz</bar>', $result, $result);
  259. $this->assertContains('</bar><status>success</status', $result, $result);
  260. }
  261. public function testHandleReturnObject()
  262. {
  263. $server = new Zend_Rest_Server();
  264. $server->addFunction('Zend_Rest_Server_TestFunc8');
  265. ob_start();
  266. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc8'));
  267. $result = ob_get_clean();
  268. $this->assertContains('<Zend_Rest_Server_TestFunc8 generator="zend" version="1.0"><foo>bar</foo><baz>1</baz><bat>123</bat><qux>0</qux><status>success</status></Zend_Rest_Server_TestFunc8>', $result, $result);
  269. }
  270. public function testHandleReturnSimpleXml()
  271. {
  272. $server = new Zend_Rest_Server();
  273. $server->setClass('Zend_Rest_Server_Test2');
  274. ob_start();
  275. $server->handle(array('method' => 'test2Xml'));
  276. $result = ob_get_clean();
  277. $this->assertContains("<foo>bar</foo>", $result, "Bad Result");
  278. }
  279. public function testHandleReturnDomDocument()
  280. {
  281. $server = new Zend_Rest_Server();
  282. $server->setClass('Zend_Rest_Server_Test2');
  283. ob_start();
  284. $server->handle(array('method' => 'test2DomDocument'));
  285. $result = ob_get_clean();
  286. $this->assertContains("<foo>bar</foo>", $result, "Bad Result");
  287. }
  288. public function testHandleReturnDomElement()
  289. {
  290. $server = new Zend_Rest_Server();
  291. $server->setClass('Zend_Rest_Server_Test2');
  292. ob_start();
  293. $server->handle(array('method' => 'test2DomElement'));
  294. $result = ob_get_clean();
  295. $this->assertContains("<foo>bar</foo>", $result, "Bad Result");
  296. }
  297. public function testHandleInvalidMethod()
  298. {
  299. $server = new Zend_Rest_Server();
  300. $server->setClass('Zend_Rest_Server_Test2');
  301. $server->returnResponse(true);
  302. $response = $server->handle(array('method' => 'test3DomElement'));
  303. $this->assertContains('<status>failed</status>', $response);
  304. }
  305. public function testFault()
  306. {
  307. $e = new Exception('testing fault');
  308. $server = new Zend_Rest_Server();
  309. $fault = $server->fault($e);
  310. $this->assertTrue($fault instanceof DOMDocument);
  311. $sx = simplexml_import_dom($fault);
  312. $this->assertTrue(isset($sx->response));
  313. $this->assertTrue(isset($sx->response->message));
  314. $this->assertContains('testing fault', (string) $sx->response->message);
  315. }
  316. public function testFaultWithoutException()
  317. {
  318. $server = new Zend_Rest_Server();
  319. $fault = $server->fault('testing fault');
  320. $this->assertTrue($fault instanceof DOMDocument);
  321. $sx = simplexml_import_dom($fault);
  322. $this->assertTrue(isset($sx->response));
  323. $this->assertTrue(isset($sx->response->message));
  324. $this->assertContains('An unknown error occured. Please try again.', (string) $sx->response->message);
  325. }
  326. public function testHandleException()
  327. {
  328. $server = new Zend_Rest_Server();
  329. $server->addFunction('Zend_Rest_Server_TestFunc11');
  330. ob_start();
  331. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc11'));
  332. $result = ob_get_clean();
  333. $this->assertContains("<Zend_Rest_Server_TestFunc11", $result);
  334. $this->assertContains("<message>testing rest server faults</message>", $result);
  335. }
  336. public function testHandleClassMethodException()
  337. {
  338. $server = new Zend_Rest_Server();
  339. $server->setClass('Zend_Rest_Server_Test2');
  340. ob_start();
  341. $server->handle(array('method' => 'test2ThrowException'));
  342. $result = ob_get_clean();
  343. $this->assertContains("<Zend_Rest_Server_Test2", $result);
  344. $this->assertContains("<test2ThrowException>", $result);
  345. $this->assertContains("<message>testing class method exception</message>", $result);
  346. }
  347. public function testHandleVoid()
  348. {
  349. $server = new Zend_Rest_Server();
  350. $server->addFunction('Zend_Rest_Server_TestFunc10');
  351. ob_start();
  352. $server->handle(array('method' => 'Zend_Rest_Server_TestFunc10'));
  353. $result = ob_get_clean();
  354. $this->assertContains('<Zend_Rest_Server_TestFunc10 generator="zend" version="1.0"><response/><status>success</status></Zend_Rest_Server_TestFunc10>', $result, $result);
  355. }
  356. public function testGetHeaders()
  357. {
  358. $server = new Zend_Rest_Server();
  359. $server->setClass('Zend_Rest_Server_Test2');
  360. ob_start();
  361. $server->handle(array('method' => 'test2ThrowException'));
  362. $result = ob_get_clean();
  363. $headers = $server->getHeaders();
  364. $this->assertContains('HTTP/1.0 400 Bad Request', $headers);
  365. }
  366. public function testReturnResponse()
  367. {
  368. $server = new Zend_Rest_Server();
  369. $this->assertFalse($server->returnResponse());
  370. $server->returnResponse(true);
  371. $this->assertTrue($server->returnResponse());
  372. }
  373. public function testReturnResponseForcesHandleToReturnResponse()
  374. {
  375. $server = new Zend_Rest_Server();
  376. $server->returnResponse(true);
  377. $server->setClass('Zend_Rest_Server_Test2');
  378. ob_start();
  379. $response = $server->handle(array('method' => 'test2Xml'));
  380. $result = ob_get_clean();
  381. $this->assertTrue(empty($result));
  382. $this->assertContains('<foo>bar</foo>', $response);
  383. }
  384. public function testGeneratedXmlEncodesScalarAmpersands()
  385. {
  386. $server = new Zend_Rest_Server();
  387. $server->returnResponse(true);
  388. $server->setClass('Zend_Rest_Server_Test');
  389. ob_start();
  390. $response = $server->handle(array('method' => 'testScalarEncoding'));
  391. $result = ob_get_clean();
  392. $this->assertTrue(empty($result));
  393. $this->assertContains('This string has chars &amp; ampersands', $response);
  394. }
  395. public function testGeneratedXmlEncodesStructAmpersands()
  396. {
  397. $server = new Zend_Rest_Server();
  398. $server->returnResponse(true);
  399. $server->setClass('Zend_Rest_Server_Test');
  400. ob_start();
  401. $response = $server->handle(array('method' => 'testStructEncoding'));
  402. $result = ob_get_clean();
  403. $this->assertTrue(empty($result));
  404. $this->assertContains('bar &amp; baz', $response);
  405. }
  406. public function testGeneratedXmlEncodesFaultAmpersands()
  407. {
  408. $server = new Zend_Rest_Server();
  409. $server->returnResponse(true);
  410. $server->setClass('Zend_Rest_Server_Test');
  411. ob_start();
  412. $response = $server->handle(array('method' => 'testExceptionsEncoding'));
  413. $result = ob_get_clean();
  414. $this->assertTrue(empty($result));
  415. $this->assertContains('testing class method exception &amp; encoding', $response);
  416. }
  417. /**
  418. * @see ZF-1992
  419. */
  420. public function testDefaultEncodingShouldBeUtf8()
  421. {
  422. $server = new Zend_Rest_Server();
  423. $this->assertEquals('UTF-8', $server->getEncoding());
  424. }
  425. /**
  426. * @see ZF-1992
  427. */
  428. public function testEncodingShouldBeMutableViaAccessors()
  429. {
  430. $server = new Zend_Rest_Server();
  431. $this->assertEquals('UTF-8', $server->getEncoding());
  432. $server->setEncoding('ISO-8859-1');
  433. $this->assertEquals('ISO-8859-1', $server->getEncoding());
  434. }
  435. /**
  436. * @see ZF-2279
  437. */
  438. public function testNamesOfArgumentsShouldDetermineArgumentOrder()
  439. {
  440. $server = new Zend_Rest_Server();
  441. $server->setClass('Zend_Rest_Server_Test');
  442. ob_start();
  443. $server->handle(array('method' => 'testFunc6', 'arg2' => 'today', 'arg1' => "Davey"));
  444. $result = ob_get_clean();
  445. $this->assertContains('<Zend_Rest_Server_Test generator="zend" version="1.0"><testFunc6><response>Hello Davey, How are you today</response><status>success</status></testFunc6></Zend_Rest_Server_Test>', $result, var_export($result, 1));
  446. }
  447. /**
  448. * @see ZF-1949
  449. */
  450. public function testMissingArgumentsShouldResultInFaultResponse()
  451. {
  452. $server = new Zend_Rest_Server();
  453. $server->setClass('Zend_Rest_Server_Test');
  454. ob_start();
  455. $server->handle(array('method' => 'testFunc6', 'arg1' => "Davey"));
  456. $result = ob_get_clean();
  457. $this->assertRegexp('#<message>Invalid Method Call to(.*?)(Requires).*?(given).*?(</message>)#', $result);
  458. $this->assertContains('<status>failed</status>', $result);
  459. }
  460. /**
  461. * @see ZF-1949
  462. */
  463. public function testMissingArgumentsWithDefaultsShouldNotResultInFaultResponse()
  464. {
  465. $server = new Zend_Rest_Server();
  466. $server->setClass('Zend_Rest_Server_Test');
  467. ob_start();
  468. $server->handle(array('method' => 'testFunc7', 'arg1' => "Davey"));
  469. $result = ob_get_clean();
  470. $this->assertContains('<status>success</status>', $result, var_export($result, 1));
  471. $this->assertContains('<response>Hello today, How are you Davey</response>', $result, var_export($result, 1));
  472. }
  473. }
  474. /* Test Functions */
  475. /**
  476. * Test Function
  477. *
  478. * @param string $arg
  479. * @return string
  480. */
  481. function Zend_Rest_Server_TestFunc($who)
  482. {
  483. return "Hello $who";
  484. }
  485. /**
  486. * Test Function 2
  487. */
  488. function Zend_Rest_Server_TestFunc2()
  489. {
  490. return "Hello World";
  491. }
  492. /**
  493. * Return false
  494. *
  495. * @return bool
  496. */
  497. function Zend_Rest_Server_TestFunc3()
  498. {
  499. return false;
  500. }
  501. /**
  502. * Return true
  503. *
  504. * @return bool
  505. */
  506. function Zend_Rest_Server_TestFunc4()
  507. {
  508. return true;
  509. }
  510. /**
  511. * Return integer
  512. *
  513. * @return int
  514. */
  515. function Zend_Rest_Server_TestFunc5()
  516. {
  517. return 123;
  518. }
  519. /**
  520. * Return string
  521. *
  522. * @return string
  523. */
  524. function Zend_Rest_Server_TestFunc6()
  525. {
  526. return "string";
  527. }
  528. /**
  529. * Return array
  530. *
  531. * @return array
  532. */
  533. function Zend_Rest_Server_TestFunc7()
  534. {
  535. return array('foo' => 'bar', 'baz' => true, 1 => false, 'bat' => 123);
  536. }
  537. /**
  538. * Return Object
  539. *
  540. * @return StdClass
  541. */
  542. function Zend_Rest_Server_TestFunc8()
  543. {
  544. $return = (object) array('foo' => 'bar', 'baz' => true, 'bat' => 123, 'qux' => false);
  545. return $return;
  546. }
  547. /**
  548. * Multiple Args
  549. *
  550. * @param string $foo
  551. * @param string $bar
  552. * @return string
  553. */
  554. function Zend_Rest_Server_TestFunc9($foo, $bar)
  555. {
  556. return "$foo $bar";
  557. }
  558. /**
  559. * Void arguments
  560. *
  561. * @return void
  562. */
  563. function Zend_Rest_Server_TestFunc10()
  564. {
  565. // returns nothing
  566. }
  567. /**
  568. * throws exception
  569. *
  570. * @return void
  571. * @throws Exception
  572. */
  573. function Zend_Rest_Server_TestFunc11()
  574. {
  575. throw new Exception('testing rest server faults');
  576. }
  577. /**
  578. * Return nested array
  579. *
  580. * @return struct
  581. */
  582. function Zend_Rest_Server_TestFunc12()
  583. {
  584. return array('foo' => array('baz' => true, 1 => false, 'bat' => 123), 'bar' => 'baz');
  585. }
  586. /**
  587. * Test Class
  588. */
  589. class Zend_Rest_Server_Test
  590. {
  591. /**
  592. * Test Function
  593. */
  594. public function testFunc()
  595. {
  596. return "Hello World";
  597. }
  598. /**
  599. * Test Function 2
  600. *
  601. * @param string $who Some Arg
  602. */
  603. public function testFunc2($who)
  604. {
  605. return "Hello $who";
  606. }
  607. /**
  608. * Test Function 3
  609. *
  610. * @param string $who Some Arg
  611. * @param int $when Some Arg2
  612. */
  613. public function testFunc3($who, $when)
  614. {
  615. return "Hello $who, How are you $when";
  616. }
  617. /**
  618. * Test Function 4
  619. */
  620. public static function testFunc4()
  621. {
  622. return "Hello World";
  623. }
  624. /**
  625. * Test Function 5
  626. *
  627. * @param string $who Some Arg
  628. */
  629. public static function testFunc5($who)
  630. {
  631. return "Hello $who";
  632. }
  633. /**
  634. * Test Function 6
  635. *
  636. * @param string $who Some Arg
  637. * @param int $when Some Arg2
  638. */
  639. public static function testFunc6($who, $when)
  640. {
  641. return "Hello $who, How are you $when";
  642. }
  643. /**
  644. * Test Function 7
  645. *
  646. * @param string $who Some Arg
  647. * @param int $when Some Arg2
  648. */
  649. public static function testFunc7($who, $when = 'today')
  650. {
  651. return "Hello $who, How are you $when";
  652. }
  653. /**
  654. * Test scalar encoding
  655. *
  656. * @return string
  657. */
  658. public function testScalarEncoding()
  659. {
  660. return 'This string has chars & ampersands';
  661. }
  662. /**
  663. * Test structs encode correctly
  664. *
  665. * @return struct
  666. */
  667. public function testStructEncoding()
  668. {
  669. return array(
  670. 'foo' => 'bar & baz'
  671. );
  672. }
  673. /**
  674. * Test exceptions encode correctly
  675. *
  676. * @return void
  677. */
  678. public function testExceptionsEncoding()
  679. {
  680. throw new Exception('testing class method exception & encoding');
  681. }
  682. }
  683. class Zend_Rest_Server_Test2
  684. {
  685. public function __construct($arg1 = 'unset')
  686. {
  687. $this->arg1 = $arg1;
  688. }
  689. public function test2Func1()
  690. {
  691. return $this->arg1;
  692. }
  693. public function test2Xml()
  694. {
  695. $sx = new SimpleXMLElement('<root><foo>bar</foo></root>');
  696. return $sx;
  697. }
  698. public function test2DomDocument()
  699. {
  700. $dom = new DOMDocument('1.0', 'UTF-8');
  701. $root = $dom->createElement('root');
  702. $dom->appendChild($root);
  703. $foo = $dom->createElement('foo', 'bar');
  704. $root->appendChild($foo);
  705. return $dom;
  706. }
  707. public function test2DomElement()
  708. {
  709. $dom = new DOMDocument('1.0', 'UTF-8');
  710. $root = $dom->createElement('root');
  711. $dom->appendChild($root);
  712. $foo = $dom->createElement('foo', 'bar');
  713. $root->appendChild($foo);
  714. return $foo;
  715. }
  716. public function test2ThrowException()
  717. {
  718. throw new Exception('testing class method exception');
  719. }
  720. public function test2Struct()
  721. {
  722. $o = new stdClass();
  723. $o->foo = array('baz' => true, 1 => false, 'bat' => 123);
  724. $o->bar = 'baz';
  725. return $o;
  726. }
  727. }
  728. class Zend_Rest_TestException extends Exception { }
  729. // Call Zend_Rest_ServerTest::main() if this source file is executed directly.
  730. if (PHPUnit_MAIN_METHOD == "Zend_Rest_ServerTest::main") {
  731. Zend_Rest_ServerTest::main();
  732. }