PageRenderTime 54ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/tests/Zend/Rest/ServerTest.php

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