PageRenderTime 60ms CodeModel.GetById 26ms RepoModel.GetById 0ms app.codeStats 1ms

/js/amplify-1.1.0/src/request/test/unit.js

https://bitbucket.org/dreamfactory/web-core
JavaScript | 1375 lines | 1249 code | 99 blank | 27 comment | 11 complexity | 97d5db5dd2ed883dbf5b4844f6966aa6 MD5 | raw file
Possible License(s): GPL-3.0, GPL-2.0
  1. (function() {
  2. var subscriptions = {};
  3. function subscribe( topic, callback ) {
  4. subscriptions[ topic ] = subscriptions[ topic ] || [];
  5. subscriptions[ topic ].push( callback );
  6. return amplify.subscribe( topic, callback );
  7. }
  8. var ajax = $.ajax;
  9. var lifecycle = {
  10. setup: function() {
  11. amplify.request.resources = {};
  12. },
  13. teardown: function() {
  14. $.ajax = ajax;
  15. $.each( subscriptions, function( topic, callbacks ) {
  16. $.each( callbacks, function( _,callback ) {
  17. amplify.unsubscribe( topic, callback );
  18. });
  19. });
  20. }
  21. };
  22. module( "amplify.request", lifecycle );
  23. test( "invalid resource id", function() {
  24. expect( 4 );
  25. subscribe( "request.before", function() {
  26. ok( false, "no messages should be published for invalid resources" );
  27. });
  28. try {
  29. amplify.request();
  30. ok( false, "should throw error with no resrouceId" );
  31. } catch( e ) {
  32. equal( e, "amplify.request: no resourceId provided" );
  33. }
  34. try {
  35. amplify.request( "missing" );
  36. ok( false, "should throw error with invalid resourceId" );
  37. } catch ( e ) {
  38. equal( e, "amplify.request: unknown resourceId: missing" );
  39. }
  40. try {
  41. amplify.request({ data: { foo: "bar" } });
  42. ok( false, "should throw error with invalid resourceId" );
  43. } catch ( e ) {
  44. equal( e, "amplify.request: no resourceId provided" );
  45. }
  46. try {
  47. amplify.request({ resourceId: "missing" });
  48. ok( false, "should throw error with invalid resourceId" );
  49. } catch ( e ) {
  50. equal( e, "amplify.request: unknown resourceId: missing" );
  51. }
  52. });
  53. module( "amplify.request.define - fn", lifecycle );
  54. asyncTest( "request( id )", function() {
  55. expect( 11 );
  56. amplify.request.define( "test", function( settings ) {
  57. equal( settings.resourceId, "test", "defintion: resouceId" );
  58. deepEqual( settings.data, {}, "definition: data" );
  59. settings.success({ simple: true });
  60. });
  61. subscribe( "request.before", function( settings ) {
  62. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  63. });
  64. subscribe( "request.success", function( settings, data, status ) {
  65. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  66. deepEqual( settings.data, {},
  67. "success message: settings.data" );
  68. deepEqual( data, { simple: true }, "success message: data" );
  69. equal( status, "success", "success message: status" );
  70. });
  71. subscribe( "request.complete", function( settings, data, status ) {
  72. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  73. deepEqual( settings.data, {},
  74. "complete message: settings.data" );
  75. deepEqual( data, { simple: true }, "complete message: data" );
  76. equal( status, "success", "complete message: status" );
  77. start();
  78. });
  79. subscribe( "request.error", function() {
  80. ok( false, "error message published" );
  81. });
  82. amplify.request( "test" );
  83. });
  84. asyncTest( "request( id, fn )", function() {
  85. expect( 13 );
  86. amplify.request.define( "test", function( settings ) {
  87. equal( settings.resourceId, "test", "defintion: resouceId" );
  88. deepEqual( settings.data, {}, "definition: data" );
  89. settings.success({ simple: true });
  90. });
  91. subscribe( "request.before", function( settings ) {
  92. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  93. });
  94. subscribe( "request.success", function( settings, data, status ) {
  95. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  96. deepEqual( settings.data, {},
  97. "success message: settings.data" );
  98. deepEqual( data, { simple: true }, "success message: data" );
  99. equal( status, "success", "success message: status" );
  100. });
  101. subscribe( "request.complete", function( settings, data, status ) {
  102. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  103. deepEqual( settings.data, {},
  104. "complete message: settings.data" );
  105. deepEqual( data, { simple: true }, "complete message: data" );
  106. equal( status, "success", "complete message: status" );
  107. start();
  108. });
  109. subscribe( "request.error", function() {
  110. ok( false, "error message published" );
  111. });
  112. amplify.request( "test", function( data, status ) {
  113. deepEqual( data, { simple: true }, "success callback: data" );
  114. equal( status, "success", "success callback: status" );
  115. });
  116. });
  117. asyncTest( "request( id, data, fn )", function() {
  118. expect( 13 );
  119. amplify.request.define( "test", function( settings ) {
  120. equal( settings.resourceId, "test", "defintion: resouceId" );
  121. deepEqual( settings.data, { foo: "bar", baz: 1 }, "definition: data" );
  122. settings.success({ simple: true });
  123. });
  124. subscribe( "request.before", function( settings ) {
  125. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  126. });
  127. subscribe( "request.success", function( settings, data, status ) {
  128. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  129. deepEqual( settings.data, { foo: "bar", baz: 1 },
  130. "success message: settings.data" );
  131. deepEqual( data, { simple: true }, "success message: data" );
  132. equal( status, "success", "success message: status" );
  133. });
  134. subscribe( "request.complete", function( settings, data, status ) {
  135. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  136. deepEqual( settings.data, { foo: "bar", baz: 1 },
  137. "complete message: settings.data" );
  138. deepEqual( data, { simple: true }, "complete message: data" );
  139. equal( status, "success", "complete message: status" );
  140. start();
  141. });
  142. subscribe( "request.error", function() {
  143. ok( false, "error message published" );
  144. });
  145. amplify.request( "test", { foo: "bar", baz: 1 }, function( data, status ) {
  146. deepEqual( data, { simple: true }, "success callback: data" );
  147. equal( status, "success", "success callback: status" );
  148. });
  149. });
  150. asyncTest( "request( hash ) success", function() {
  151. expect( 13 );
  152. amplify.request.define( "test", function( settings ) {
  153. equal( settings.resourceId, "test", "defintion: resouceId" );
  154. deepEqual( settings.data, { foo: "bar", baz: 1 }, "definition: data" );
  155. settings.success({ simple: true });
  156. });
  157. subscribe( "request.before", function( settings ) {
  158. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  159. });
  160. subscribe( "request.success", function( settings, data, status ) {
  161. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  162. deepEqual( settings.data, { foo: "bar", baz: 1 },
  163. "success message: settings.data" );
  164. deepEqual( data, { simple: true }, "success message: data" );
  165. equal( status, "success", "success message: status" );
  166. });
  167. subscribe( "request.complete", function( settings, data, status ) {
  168. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  169. deepEqual( settings.data, { foo: "bar", baz: 1 },
  170. "complete message: settings.data" );
  171. deepEqual( data, { simple: true }, "complete message: data" );
  172. equal( status, "success", "complete message: status" );
  173. start();
  174. });
  175. subscribe( "request.error", function() {
  176. ok( false, "error message published" );
  177. });
  178. amplify.request({
  179. resourceId: "test",
  180. data: { foo: "bar", baz: 1 },
  181. success: function( data, status ) {
  182. deepEqual( data, { simple: true }, "success callback: data" );
  183. equal( status, "success", "success callback: status" );
  184. }
  185. });
  186. });
  187. asyncTest( "request( hash ) error", function() {
  188. expect( 13 );
  189. amplify.request.define( "test", function( settings ) {
  190. equal( settings.resourceId, "test", "defintion: resouceId" );
  191. deepEqual( settings.data, { foo: "bar", baz: 1 }, "definition: data" );
  192. settings.error({ simple: true });
  193. });
  194. subscribe( "request.before", function( settings ) {
  195. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  196. });
  197. subscribe( "request.error", function( settings, data, status ) {
  198. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  199. deepEqual( settings.data, { foo: "bar", baz: 1 },
  200. "error message: settings.data" );
  201. deepEqual( data, { simple: true }, "error message: data" );
  202. equal( status, "error", "error message: status" );
  203. });
  204. subscribe( "request.complete", function( settings, data, status ) {
  205. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  206. deepEqual( settings.data, { foo: "bar", baz: 1 },
  207. "complete message: settings.data" );
  208. deepEqual( data, { simple: true }, "complete message: data" );
  209. equal( status, "error", "complete message: status" );
  210. start();
  211. });
  212. subscribe( "request.success", function() {
  213. ok( false, "success message published" );
  214. });
  215. amplify.request({
  216. resourceId: "test",
  217. data: { foo: "bar", baz: 1 },
  218. success: function() {
  219. ok( false, "success callback invoked" );
  220. },
  221. error: function( data, status ) {
  222. deepEqual( data, { simple: true }, "error callback: data" );
  223. equal( status, "error", "error callback: status" );
  224. }
  225. });
  226. });
  227. asyncTest( "custom status - success", function() {
  228. expect( 6 );
  229. amplify.request.define( "test", function( settings ) {
  230. settings.success( { data: "is good" }, "custom status" );
  231. });
  232. subscribe( "request.success", function( settings, data, status ) {
  233. deepEqual( data, { data: "is good" }, "success message: data " );
  234. equal( status, "custom status", "success message: status" );
  235. });
  236. subscribe( "request.complete", function( settings, data, status ) {
  237. deepEqual( data, { data: "is good" }, "complete message: data " );
  238. equal( status, "custom status", "complete message: status" );
  239. start();
  240. });
  241. amplify.request( "test", function( data, status ) {
  242. deepEqual( data, { data: "is good" }, "success callback: data " );
  243. equal( status, "custom status", "success callback: status" );
  244. });
  245. });
  246. asyncTest( "custom status - error", function() {
  247. expect( 6 );
  248. amplify.request.define( "test", function( settings ) {
  249. settings.error( { data: "is bad" }, "custom error" );
  250. });
  251. subscribe( "request.error", function( settings, data, status ) {
  252. deepEqual( data, { data: "is bad" }, "error message: data " );
  253. equal( status, "custom error", "error message: status" );
  254. });
  255. subscribe( "request.complete", function( settings, data, status ) {
  256. deepEqual( data, { data: "is bad" }, "complete message: data " );
  257. equal( status, "custom error", "complete message: status" );
  258. start();
  259. });
  260. amplify.request({
  261. resourceId: "test",
  262. error: function( data, status ) {
  263. deepEqual( data, { data: "is bad" }, "error callback: data " );
  264. equal( status, "custom error", "error callback: status" );
  265. }
  266. });
  267. });
  268. asyncTest( "prevent request", function() {
  269. expect( 3 );
  270. amplify.request.define( "test", function( settings ) {
  271. deepEqual( settings.data, { pass: true }, "request occurred" );
  272. start();
  273. });
  274. subscribe( "request.before", function( settings ) {
  275. ok( true, "message published" );
  276. return settings.data.pass;
  277. });
  278. amplify.request( "test", { pass: false } );
  279. amplify.request( "test", { pass: true } );
  280. });
  281. module( "amplify.request.define - ajax", lifecycle );
  282. asyncTest( "request( id )", function() {
  283. expect( 23 );
  284. var ajax = $.ajax;
  285. $.ajax = function( settings ) {
  286. equal( settings.url, "data/data.json", "correct url" );
  287. equal( settings.dataType, "json", "correct dataType" );
  288. equal( settings.type, "GET", "default type" );
  289. ajax.apply( this, arguments );
  290. };
  291. amplify.request.define( "test", "ajax", {
  292. url: "data/data.json",
  293. dataType: "json"
  294. });
  295. subscribe( "request.before", function( settings ) {
  296. equal( settings.resourceId, "test", "before message: settings.resourceId" );
  297. deepEqual( settings.data, {}, "before message: settings.data" );
  298. });
  299. subscribe( "request.before.ajax", function( resource, settings, ajaxSettings, xhr ) {
  300. equal( resource.resourceId, "test", "before.ajax message: resource.resourceId" );
  301. equal( resource.url, "data/data.json", "before.ajax message: resource.url" );
  302. equal( resource.dataType, "json", "before.ajax message: resource.dataType" );
  303. equal( resource.type, "GET", "before.ajax message: resource.type" );
  304. equal( settings.resourceId, "test", "before.ajax message: settings.resourceId" );
  305. deepEqual( settings.data, {}, "before.ajax message: settings.data" );
  306. equal( ajaxSettings.url, "data/data.json", "before.ajax message: ajaxSettings.url" );
  307. equal( ajaxSettings.dataType, "json", "before.ajax message: ajaxSettings.dataType" );
  308. equal( ajaxSettings.type, "GET", "before.ajax message: ajaxSettings.type" );
  309. ok( "abort" in xhr, "before.ajax message: xhr object provided" );
  310. });
  311. subscribe( "request.success", function( settings, data, status ) {
  312. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  313. deepEqual( settings.data, {}, "success message: settings.data" );
  314. deepEqual( data, { foo: "bar" }, "success message: data" );
  315. equal( status, "success", "success message: status" );
  316. });
  317. subscribe( "request.complete", function( settings, data, status ) {
  318. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  319. deepEqual( settings.data, {}, "complete message: settings.data" );
  320. deepEqual( data, { foo: "bar" }, "complete message: data" );
  321. equal( status, "success", "complete message: status" );
  322. start();
  323. });
  324. subscribe( "request.error", function() {
  325. ok( false, "error message published" );
  326. });
  327. amplify.request( "test" );
  328. });
  329. asyncTest( "request( id, fn )", function() {
  330. expect( 10 );
  331. amplify.request.define( "test", "ajax", {
  332. url: "data/data.json",
  333. dataType: "json"
  334. });
  335. subscribe( "request.success", function( settings, data, status ) {
  336. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  337. deepEqual( settings.data, {}, "success message: settings.data" );
  338. deepEqual( data, { foo: "bar" }, "success message: data" );
  339. equal( status, "success", "success message: status" );
  340. });
  341. subscribe( "request.complete", function( settings, data, status ) {
  342. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  343. deepEqual( settings.data, {}, "complete message: settings.data" );
  344. deepEqual( data, { foo: "bar" }, "complete message: data" );
  345. equal( status, "success", "complete message: status" );
  346. start();
  347. });
  348. amplify.request( "test", function( data, status ) {
  349. deepEqual( data, { foo: "bar" }, "success callback: data" );
  350. equal( status, "success", "success callback: status" );
  351. });
  352. });
  353. asyncTest( "request( id, data, fn )", function() {
  354. expect( 10 );
  355. amplify.request.define( "test", "ajax", {
  356. url: "data/echo.php",
  357. dataType: "json",
  358. type: "POST"
  359. });
  360. subscribe( "request.success", function( settings, data, status ) {
  361. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  362. deepEqual( settings.data, { open: "source" }, "success message: settings.data" );
  363. deepEqual( data, { open: "source", echoed: true }, "success message: data" );
  364. equal( status, "success", "success message: status" );
  365. });
  366. subscribe( "request.complete", function( settings, data, status ) {
  367. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  368. deepEqual( settings.data, { open: "source" }, "complete message: settings.data" );
  369. deepEqual( data, { open: "source", echoed: true }, "complete message: data" );
  370. equal( status, "success", "complete message: status" );
  371. start();
  372. });
  373. amplify.request( "test", { open: "source" }, function( data, status ) {
  374. deepEqual( data, { open: "source", echoed: true }, "success callback: data" );
  375. equal( status, "success", "success callback: status" );
  376. });
  377. });
  378. asyncTest( "request( hash ) success", function() {
  379. expect( 8 );
  380. amplify.request.define( "test", "ajax", {
  381. url: "data/data.json",
  382. dataType: "json"
  383. });
  384. subscribe( "request.success", function( settings, data, status ) {
  385. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  386. deepEqual( data, { foo: "bar" }, "success message: data" );
  387. equal( status, "success", "success message: status" );
  388. });
  389. subscribe( "request.complete", function( settings, data, status ) {
  390. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  391. deepEqual( data, { foo: "bar" }, "complete message: data" );
  392. equal( status, "success", "complete message: status" );
  393. start();
  394. });
  395. subscribe( "request.error", function() {
  396. ok( false, "error message published" );
  397. });
  398. amplify.request({
  399. resourceId: "test",
  400. success: function( data, status ) {
  401. deepEqual( data, { foo: "bar" }, "success callback: data" );
  402. equal( status, "success", "success callback: status" );
  403. },
  404. error: function() {
  405. ok( false, "error callback invoked" );
  406. }
  407. });
  408. });
  409. asyncTest( "request( hash ) error", function() {
  410. expect( 8 );
  411. amplify.request.define( "test", "ajax", {
  412. url: "data/missing.html",
  413. dataType: "json"
  414. });
  415. subscribe( "request.error", function( settings, data, status ) {
  416. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  417. deepEqual( data, null, "error message: data" );
  418. equal( status, "error", "error message: status" );
  419. });
  420. subscribe( "request.complete", function( settings, data, status ) {
  421. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  422. deepEqual( data, null, "complete message: data" );
  423. equal( status, "error", "complete message: status" );
  424. start();
  425. });
  426. subscribe( "request.success", function() {
  427. ok( false, "success message published" );
  428. });
  429. amplify.request({
  430. resourceId: "test",
  431. error: function( data, status ) {
  432. deepEqual( data, null, "error callback: data" );
  433. equal( status, "error", "error callback: status" );
  434. },
  435. success: function() {
  436. ok( false, "success callback invoked" );
  437. }
  438. });
  439. });
  440. asyncTest( "prevent request - beforeSend", function() {
  441. expect( 10 );
  442. amplify.request.define( "test", "ajax", {
  443. url: "data/data.json",
  444. dataType: "json",
  445. // should execute 2 times
  446. beforeSend: function( xhr, settings ) {
  447. ok( "abort" in xhr, "xhr object provided" );
  448. equal( settings.url.substring( 0, 20 ), "data/data.json?pass=", "correct url" );
  449. equal( settings.dataType, "json", "correct dataType" );
  450. return settings.url.substring( settings.url.length - 4 ) === "true";
  451. }
  452. });
  453. // should execute 2 times
  454. subscribe( "request.before", function( settings ) {
  455. ok( true, "before message published" );
  456. });
  457. // should execute 1 time
  458. subscribe( "request.before.ajax", function( settings ) {
  459. ok( true, "before.ajax message published" );
  460. });
  461. // should execute 1 time
  462. subscribe( "request.complete", function( settings ) {
  463. ok( settings.data.pass, "request completed" );
  464. start();
  465. });
  466. amplify.request( "test", { pass: false } );
  467. amplify.request( "test", { pass: true } );
  468. });
  469. asyncTest( "prevent request - request.before", function() {
  470. expect( 4 );
  471. amplify.request.define( "test", "ajax", {
  472. url: "data/data.json",
  473. dataType: "json"
  474. });
  475. subscribe( "request.before", function( settings ) {
  476. ok( true, "message published" );
  477. return settings.data.pass;
  478. });
  479. subscribe( "request.complete", function( settings, data, status ) {
  480. if ( !settings.data.pass ) {
  481. equal( status, "abort", "aborted" );
  482. } else {
  483. equal( status, "success", "successful" );
  484. start();
  485. }
  486. });
  487. amplify.request( "test", { pass: false } );
  488. amplify.request( "test", { pass: true } );
  489. });
  490. asyncTest( "prevent request - request.before.ajax", function() {
  491. expect( 3 );
  492. amplify.request.define( "test", "ajax", {
  493. url: "data/data.json",
  494. dataType: "json"
  495. });
  496. subscribe( "request.before.ajax", function( resouce, settings ) {
  497. ok( true, "message published" );
  498. return settings.data.pass;
  499. });
  500. subscribe( "request.complete", function( settings, data, status ) {
  501. if ( !settings.data.pass ) {
  502. equal( status, "abort", "aborted" );
  503. } else {
  504. equal( status, "success", "successful" );
  505. start();
  506. }
  507. });
  508. amplify.request( "test", { pass: false } );
  509. amplify.request( "test", { pass: true } );
  510. });
  511. test( "data merging", function() {
  512. expect( 3 );
  513. $.ajax = function( settings ) {
  514. deepEqual( settings.data, {
  515. foo: "bar",
  516. bar: "baz",
  517. baz: "qux"
  518. }, "default data passed through" );
  519. };
  520. amplify.request.define( "test", "ajax", {
  521. url: "",
  522. data: {
  523. foo: "bar",
  524. bar: "baz",
  525. baz: "qux"
  526. }
  527. });
  528. amplify.request( "test" );
  529. amplify.request( "test", {} );
  530. $.ajax = function( settings ) {
  531. deepEqual( settings.data, {
  532. foo: "changed",
  533. bar: "baz",
  534. baz: {
  535. qux: "remains",
  536. quux: "is changed"
  537. }
  538. }, "data merged" );
  539. };
  540. amplify.request.define( "test", "ajax", {
  541. url: "",
  542. data: {
  543. foo: "bar",
  544. bar: "baz",
  545. baz: {
  546. qux: "remains",
  547. quux: "changes"
  548. }
  549. }
  550. });
  551. amplify.request( "test", {
  552. foo: "changed",
  553. baz: {
  554. quux: "is changed"
  555. }
  556. });
  557. });
  558. test( "url substitution", function() {
  559. expect( 7 );
  560. $.ajax = function( settings ) {
  561. equal( settings.url, "/path/bar", "url" );
  562. deepEqual( settings.data, {}, "data" );
  563. };
  564. amplify.request.define( "test", "ajax", {
  565. url: "/path/{foo}",
  566. data: {
  567. foo: "bar"
  568. }
  569. });
  570. amplify.request( "test" );
  571. $.ajax = function( settings ) {
  572. equal( settings.url, "/path/qux", "url" );
  573. deepEqual( settings.data, {}, "data" );
  574. };
  575. amplify.request( "test", { foo: "qux" } );
  576. $.ajax = function( settings ) {
  577. equal( settings.url, "/path/bar", "url" );
  578. deepEqual( settings.data, { qux: "quux" }, "data" );
  579. };
  580. amplify.request( "test", { qux: "quux" } );
  581. $.ajax = function( settings ) {
  582. equal( settings.url, "/a/bar/b/bar", "url" );
  583. };
  584. amplify.request.define( "test", "ajax", {
  585. url: "/a/{foo}/b/{foo}"
  586. });
  587. amplify.request( "test", { foo: "bar" } );
  588. });
  589. asyncTest( "data as string", function() {
  590. expect( 1 );
  591. amplify.request.define( "test", "ajax", {
  592. url: "data/echo-raw.php",
  593. type: "POST"
  594. });
  595. amplify.request( "test", "sending {raw} [data]", function( data ) {
  596. equal( data, "sending {raw} [data]" );
  597. start();
  598. });
  599. });
  600. test( "dataMap: hash", function() {
  601. expect( 1 );
  602. $.ajax = function( settings ) {
  603. deepEqual( settings.data, {
  604. sillyNameForFoo: "foo val",
  605. bar: "bar val"
  606. }, "keys mapped" );
  607. };
  608. amplify.request.define( "test", "ajax", {
  609. url: "",
  610. dataMap: {
  611. foo: "sillyNameForFoo",
  612. baz: "sillyNameForBaz"
  613. }
  614. });
  615. amplify.request( "test", {
  616. foo: "foo val",
  617. bar: "bar val"
  618. });
  619. });
  620. test( "dataMap: function", function() {
  621. expect( 2 );
  622. $.ajax = function( settings ) {
  623. deepEqual( settings.data, {
  624. foo: "bar",
  625. baz: "qux"
  626. }, "keys mapped" );
  627. };
  628. amplify.request.define( "test", "ajax", {
  629. url: "",
  630. dataMap: function( data ) {
  631. deepEqual( data, {
  632. orig: "data"
  633. }, "original data in dataMap" );
  634. return {
  635. foo: "bar",
  636. baz: "qux"
  637. };
  638. }
  639. });
  640. amplify.request( "test", {
  641. orig: "data"
  642. });
  643. });
  644. asyncTest( "abort", function() {
  645. expect( 9 );
  646. amplify.request.define( "test", "ajax", {
  647. url: "data/delay.php",
  648. dataType: "json",
  649. cache: false
  650. });
  651. var request = amplify.request({
  652. resourceId: "test",
  653. error: function( data, status ) {
  654. deepEqual( data, null, "error callback: data" );
  655. equal( status, "abort", "error callback: status" );
  656. },
  657. success: function() {
  658. ok( false, "success callback invoked" );
  659. }
  660. });
  661. subscribe( "request.error", function( settings, data, status ) {
  662. equal( settings.resourceId, "test", "error message: resourceId" );
  663. deepEqual( data, null, "error message: data" );
  664. equal( status, "abort", "error message: status" );
  665. });
  666. subscribe( "request.complete", function( settings, data, status ) {
  667. equal( settings.resourceId, "test", "complete message: resourceId" );
  668. deepEqual( data, null, "complete message: data" );
  669. equal( status, "abort", "complete message: status" );
  670. start();
  671. });
  672. subscribe( "request.success", function() {
  673. ok( false, "success message published" );
  674. });
  675. ok( "abort" in request, "request object has abort method" );
  676. request.abort();
  677. // make sure calling abort() multiple times does nothing
  678. // tested via expected number of assertions
  679. request.abort();
  680. });
  681. asyncTest( "ampXHR", function() {
  682. expect( 7 );
  683. var ampXHR;
  684. amplify.request.define( "ampXHR", "ajax", {
  685. // prevent caching to ensure we get proper headers
  686. cache: false,
  687. url: "data/headers.php",
  688. dataType: "json"
  689. });
  690. subscribe( "request.before.ajax", function( resource, settings, ajaxSettings, xhr ) {
  691. ampXHR = xhr;
  692. ampXHR.setRequestHeader( "X-Amplify-Request", "custom request header" );
  693. });
  694. subscribe( "request.success", function( settings, data, status ) {
  695. equal( ampXHR.readyState, 4, "ampXHR.readyState" );
  696. deepEqual( data, { header: "custom request header" }, "ampXHR.setRequestHeader()" );
  697. equal( ampXHR.getResponseHeader( "X-Amplify-Response" ), "custom response header",
  698. "ampXHR.getResponseHeader()" );
  699. ok( ampXHR.getAllResponseHeaders().toLowerCase().indexOf(
  700. "x-amplify-response: custom response header" ) !== -1,
  701. "ampXHR.getAllResponseHeaders()" );
  702. equal( ampXHR.status, 200, "ampXHR.status" );
  703. equal( ampXHR.statusText, "success", "ampXHR.statusText" );
  704. equal( ampXHR.responseText, "{\"header\":\"custom request header\"}",
  705. "ampXHR.responseText" );
  706. });
  707. subscribe( "request.complete", function() {
  708. start();
  709. });
  710. subscribe( "request.error", function() {
  711. ok( false, "error message published" );
  712. });
  713. amplify.request( "ampXHR" );
  714. });
  715. test( "cache keys", function() {
  716. expect( 2 );
  717. equal( amplify.request.cache._key( "x", "" ), "request-x-1996950016" );
  718. equal( amplify.request.cache._key( "x", "foo=bar" ), "request-x-50601290" );
  719. });
  720. asyncTest( "cache: true", function() {
  721. expect( 14 );
  722. var ajaxCalls = 0;
  723. $( "#ajax-listener" ).ajaxComplete(function( event, xhr ) {
  724. if ( xhr.statusText !== "abort" ) {
  725. ok( !ajaxCalls++, "ajax call completed" );
  726. }
  727. });
  728. amplify.request.define( "memory-cache", "ajax", {
  729. url: "data/data.json",
  730. dataType: "json",
  731. cache: true
  732. });
  733. // should execute for both requests
  734. subscribe( "request.before", function( settings ) {
  735. equal( settings.resourceId, "memory-cache", "before message: settings.resourceId" );
  736. });
  737. // should execute for first request only
  738. subscribe( "request.before.ajax", function( resource ) {
  739. equal( resource.resourceId, "memory-cache", "before.ajax message: resource.resourceId" );
  740. });
  741. // should execute for both requests
  742. subscribe( "request.success", function( settings, data ) {
  743. equal( settings.resourceId, "memory-cache", "success message: settings.resourceId" );
  744. deepEqual( data, { foo: "bar" }, "success message: data" );
  745. });
  746. // should execute for both requests
  747. subscribe( "request.complete", function( settings, data ) {
  748. equal( settings.resourceId, "memory-cache", "complete message: settings.resourceId" );
  749. deepEqual( data, { foo: "bar" }, "complete message: data" );
  750. });
  751. subscribe( "request.error", function() {
  752. ok( false, "error message published" );
  753. });
  754. amplify.request( "memory-cache", function( data ) {
  755. deepEqual( data, { foo: "bar" }, "first request callback" );
  756. amplify.request( "memory-cache", function( data ) {
  757. deepEqual( data, { foo: "bar" }, "second request callback" );
  758. start();
  759. });
  760. });
  761. });
  762. asyncTest( "cache with data", function() {
  763. expect( 8 );
  764. var expectAjax = true;
  765. amplify.request.define( "data-cache", "ajax", {
  766. url: "data/echo-raw.php",
  767. cache: true
  768. });
  769. subscribe( "request.before.ajax", function() {
  770. ok( expectAjax );
  771. });
  772. amplify.request( "data-cache", function( data ) {
  773. equal( data, "empty", "no data; empty cache" );
  774. amplify.request( "data-cache", { foo: "bar" }, function( data ) {
  775. equal( data, "foo=bar", "data; empty cache" );
  776. amplify.request( "data-cache", { foo: "qux" }, function( data ) {
  777. equal( data, "foo=qux", "different data; empty cache" );
  778. expectAjax = false;
  779. amplify.request( "data-cache", { foo: "bar" }, function( data ) {
  780. equal( data, "foo=bar", "data; cached" );
  781. amplify.request( "data-cache", function( data ) {
  782. equal( data, "empty", "no data; cached" );
  783. start();
  784. });
  785. });
  786. });
  787. });
  788. });
  789. });
  790. asyncTest( "cache with data-replaced URL", function() {
  791. expect( 5 );
  792. var expectAjax = true;
  793. amplify.request.define( "data-cache-url", "ajax", {
  794. url: "data/echo-raw.php?{foo}",
  795. cache: true
  796. });
  797. subscribe( "request.before.ajax", function() {
  798. ok( expectAjax );
  799. });
  800. amplify.request( "data-cache-url", { foo: "bar" }, function( data ) {
  801. equal( data, "bar", "data; empty cache" );
  802. amplify.request( "data-cache-url", { foo: "qux" }, function( data ) {
  803. equal( data, "qux", "different data; empty cache" );
  804. expectAjax = false;
  805. amplify.request( "data-cache-url", { foo: "bar" }, function( data ) {
  806. equal( data, "bar", "data; cached" );
  807. start();
  808. });
  809. });
  810. });
  811. });
  812. asyncTest( "cache: Number", function() {
  813. expect( 22 );
  814. var shouldCache = false;
  815. $( "#ajax-listener" ).ajaxComplete(function( event, xhr ) {
  816. if ( xhr.statusText !== "abort" ) {
  817. ok( !shouldCache, "ajax call completed" );
  818. }
  819. });
  820. amplify.request.define( "cache-duration", "ajax", {
  821. url: "data/data.json",
  822. dataType: "json",
  823. cache: 500
  824. });
  825. // should execute for 3 requests
  826. subscribe( "request.before", function( settings ) {
  827. equal( settings.resourceId, "cache-duration", "before message: settings.resourceId" );
  828. });
  829. // should execute for 2 requests
  830. subscribe( "request.before.ajax", function( resource ) {
  831. equal( resource.resourceId, "cache-duration", "before.ajax message: resource.resourceId" );
  832. });
  833. // should execute for 3 requests
  834. subscribe( "request.success", function( settings, data ) {
  835. equal( settings.resourceId, "cache-duration", "success message: settings.resourceId" );
  836. deepEqual( data, { foo: "bar" }, "success message: data" );
  837. });
  838. // should execute for 3 requests
  839. subscribe( "request.complete", function( settings, data ) {
  840. equal( settings.resourceId, "cache-duration", "complete message: settings.resourceId" );
  841. deepEqual( data, { foo: "bar" }, "complete message: data" );
  842. });
  843. subscribe( "request.error", function() {
  844. ok( false, "error message published" );
  845. });
  846. amplify.request( "cache-duration", function( data ) {
  847. // delay setting the flag because the success callback will be invoked
  848. // before the ajaxComplete event is triggered
  849. setTimeout(function() {
  850. shouldCache = true;
  851. }, 1 );
  852. deepEqual( data, { foo: "bar" }, "first request callback" );
  853. amplify.request( "cache-duration", function( data ) {
  854. deepEqual( data, { foo: "bar" }, "second request callback" );
  855. });
  856. setTimeout(function() {
  857. shouldCache = false;
  858. amplify.request( "cache-duration", function( data ) {
  859. deepEqual( data, { foo: "bar" }, "third request callback" );
  860. start();
  861. });
  862. }, 700 );
  863. });
  864. });
  865. if ( amplify.store ) {
  866. var storeExpiresLifecycle = {
  867. setup: function() {
  868. $.each( amplify.store(), function( key ) {
  869. if ( /^request/.test( key ) ) {
  870. amplify.store( key, null );
  871. }
  872. });
  873. }
  874. };
  875. asyncTest( "cache: persist - no expires", storeExpiresLifecycle, function() {
  876. expect( 15 );
  877. var ajaxCalls = 0;
  878. $( "#ajax-listener" ).ajaxComplete(function( event, xhr ) {
  879. if ( xhr.statusText !== "abort" ) {
  880. ok( !ajaxCalls++, "ajax call completed" );
  881. }
  882. });
  883. amplify.request.define( "persist-cache", "ajax", {
  884. url: "data/data.json",
  885. dataType: "json",
  886. cache: "persist"
  887. });
  888. // should execute for both requests
  889. subscribe( "request.before", function( settings ) {
  890. equal( settings.resourceId, "persist-cache", "before message: settings.resourceId" );
  891. });
  892. // should execute for first request only
  893. subscribe( "request.before.ajax", function( resource ) {
  894. equal( resource.resourceId, "persist-cache", "before.ajax message: resource.resourceId" );
  895. equal( resource.cache.expires, undefined, "before.ajax message: resource.expires");
  896. });
  897. // should execute for both requests
  898. subscribe( "request.success", function( settings, data ) {
  899. equal( settings.resourceId, "persist-cache", "success message: settings.resourceId" );
  900. deepEqual( data, { foo: "bar" }, "success message: data" );
  901. });
  902. // should execute for both requests
  903. subscribe( "request.complete", function( settings, data ) {
  904. equal( settings.resourceId, "persist-cache", "complete message: settings.resourceId" );
  905. deepEqual( data, { foo: "bar" }, "complete message: data" );
  906. });
  907. subscribe( "request.error", function() {
  908. ok( false, "error message published" );
  909. });
  910. amplify.request( "persist-cache", function( data ) {
  911. deepEqual( data, { foo: "bar" }, "first request callback" );
  912. amplify.request( "persist-cache", function( data ) {
  913. deepEqual( data, { foo: "bar" }, "second request callback" );
  914. start();
  915. });
  916. });
  917. });
  918. asyncTest( "cache: persist - expires", storeExpiresLifecycle, function() {
  919. expect( 24 );
  920. var shouldCache = false;
  921. $( "#ajax-listener" ).ajaxComplete(function( event, xhr ) {
  922. if ( xhr.statusText !== "abort" ) {
  923. ok( !shouldCache, "ajax call completed" );
  924. }
  925. });
  926. amplify.request.define( "persist-cache", "ajax", {
  927. url: "data/data.json",
  928. dataType: "json",
  929. cache: { type: "persist", expires: 450 }
  930. });
  931. // should execute for 3 requests
  932. subscribe( "request.before", function( settings ) {
  933. equal( settings.resourceId, "persist-cache", "before message: settings.resourceId" );
  934. });
  935. // should execute for 2 requests
  936. subscribe( "request.before.ajax", function( resource ) {
  937. equal( resource.resourceId, "persist-cache", "before.ajax message: resource.resourceId" );
  938. equal( resource.cache.expires, 450, "before.ajax message: resource.expires");
  939. });
  940. // should execute 3 requests
  941. subscribe( "request.success", function( settings, data ) {
  942. equal( settings.resourceId, "persist-cache", "success message: settings.resourceId" );
  943. deepEqual( data, { foo: "bar" }, "success message: data" );
  944. });
  945. // should execute for 3 requests
  946. subscribe( "request.complete", function( settings, data ) {
  947. equal( settings.resourceId, "persist-cache", "complete message: settings.resourceId" );
  948. deepEqual( data, { foo: "bar" }, "complete message: data" );
  949. });
  950. subscribe( "request.error", function() {
  951. ok( false, "error message published" );
  952. });
  953. amplify.request( "persist-cache", function( data ) {
  954. // delay setting the flag because the success callback will be invoked
  955. // before the ajaxComplete event is triggered
  956. setTimeout(function() {
  957. shouldCache = true;
  958. }, 1 );
  959. deepEqual( data, { foo: "bar" }, "first request callback" );
  960. amplify.request( "persist-cache", function( data ) {
  961. deepEqual( data, { foo: "bar" }, "second request callback" );
  962. });
  963. setTimeout(function() {
  964. shouldCache = false;
  965. amplify.request( "persist-cache", function( data ) {
  966. deepEqual( data, { foo: "bar" }, "third request callback" );
  967. start();
  968. });
  969. }, 500 );
  970. });
  971. });
  972. test( "cache types", function() {
  973. $.each( amplify.store.types, function( type ) {
  974. ok( type in amplify.request.cache, type );
  975. });
  976. });
  977. }
  978. asyncTest( "decoder: Function - success", function() {
  979. expect( 11 );
  980. amplify.request.define( "test", "ajax", {
  981. url: "data/data.json",
  982. dataType: "json",
  983. decoder: function( data, status, xhr, success, error ) {
  984. deepEqual( data, { foo: "bar" }, "data in decoder" );
  985. equal( status, "success", "status in decoder" );
  986. ok( "abort" in xhr, "xhr in decoder" );
  987. success({ baz: "qux" });
  988. }
  989. });
  990. subscribe( "request.success", function( settings, data, status ) {
  991. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  992. deepEqual( data, { baz: "qux" }, "success message: data" );
  993. equal( status, "success", "success message: status" );
  994. });
  995. subscribe( "request.complete", function( settings, data, status ) {
  996. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  997. deepEqual( data, { baz: "qux" }, "complete message: data" );
  998. equal( status, "success", "complete message: status" );
  999. start();
  1000. });
  1001. subscribe( "request.error", function() {
  1002. ok( false, "error message published" );
  1003. });
  1004. amplify.request({
  1005. resourceId: "test",
  1006. success: function( data, status ) {
  1007. deepEqual( data, { baz: "qux" }, "success callback: data" );
  1008. equal( status, "success", "success callback: status" );
  1009. },
  1010. error: function() {
  1011. ok( false, "error callback invoked" );
  1012. }
  1013. });
  1014. });
  1015. asyncTest( "decoder: Function - error", function() {
  1016. expect( 11 );
  1017. amplify.request.define( "test", "ajax", {
  1018. url: "data/data.json",
  1019. dataType: "json",
  1020. decoder: function( data, status, xhr, success, error ) {
  1021. deepEqual( data, { foo: "bar" }, "data in decoder" );
  1022. equal( status, "success", "status in decoder" );
  1023. ok( "abort" in xhr, "xhr in decoder" );
  1024. error({ baz: "qux" });
  1025. }
  1026. });
  1027. subscribe( "request.error", function( settings, data, status ) {
  1028. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  1029. deepEqual( data, { baz: "qux" }, "error message: data" );
  1030. equal( status, "error", "error message: status" );
  1031. });
  1032. subscribe( "request.complete", function( settings, data, status ) {
  1033. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1034. deepEqual( data, { baz: "qux" }, "complete message: data" );
  1035. equal( status, "error", "complete message: status" );
  1036. start();
  1037. });
  1038. subscribe( "request.success", function() {
  1039. ok( false, "success message published" );
  1040. });
  1041. amplify.request({
  1042. resourceId: "test",
  1043. success: function() {
  1044. ok( false, "success callback invoked" );
  1045. },
  1046. error: function( data, status ) {
  1047. deepEqual( data, { baz: "qux" }, "error callback: data" );
  1048. equal( status, "error", "error callback: status" );
  1049. }
  1050. });
  1051. });
  1052. asyncTest( "decoder: jsend - success", function() {
  1053. expect( 8 );
  1054. amplify.request.define( "test", "ajax", {
  1055. url: "data/jsend.json",
  1056. dataType: "json",
  1057. decoder: "jsend"
  1058. });
  1059. subscribe( "request.success", function( settings, data, status ) {
  1060. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  1061. deepEqual( data, { unwrapped: true }, "success message: data" );
  1062. equal( status, "success", "success message: status" );
  1063. });
  1064. subscribe( "request.complete", function( settings, data, status ) {
  1065. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1066. deepEqual( data, { unwrapped: true }, "complete message: data" );
  1067. equal( status, "success", "complete message: status" );
  1068. start();
  1069. });
  1070. subscribe( "request.error", function() {
  1071. ok( false, "error message published" );
  1072. });
  1073. amplify.request({
  1074. resourceId: "test",
  1075. success: function( data, status ) {
  1076. deepEqual( data, { unwrapped: true }, "success callback: data" );
  1077. equal( status, "success", "success callback: status" );
  1078. },
  1079. error: function() {
  1080. ok( false, "error callback invoked" );
  1081. }
  1082. });
  1083. });
  1084. asyncTest( "decoder: jsend - fail", function() {
  1085. expect( 8 );
  1086. amplify.request.define( "test", "ajax", {
  1087. url: "data/jsend-fail.json",
  1088. dataType: "json",
  1089. decoder: "jsend"
  1090. });
  1091. subscribe( "request.error", function( settings, data, status ) {
  1092. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  1093. deepEqual( data, { broken: true }, "error message: data" );
  1094. equal( status, "fail", "error message: status" );
  1095. });
  1096. subscribe( "request.complete", function( settings, data, status ) {
  1097. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1098. deepEqual( data, { broken: true }, "complete message: data" );
  1099. equal( status, "fail", "complete message: status" );
  1100. start();
  1101. });
  1102. subscribe( "request.success", function() {
  1103. ok( false, "success message published" );
  1104. });
  1105. amplify.request({
  1106. resourceId: "test",
  1107. success: function() {
  1108. ok( false, "success callback invoked" );
  1109. },
  1110. error: function( data, status ) {
  1111. deepEqual( data, { broken: true }, "error callback: data" );
  1112. equal( status, "fail", "error callback: status" );
  1113. }
  1114. });
  1115. });
  1116. asyncTest( "decoder: jsend - error", function() {
  1117. expect( 8 );
  1118. amplify.request.define( "test", "ajax", {
  1119. url: "data/jsend-error.json",
  1120. dataType: "json",
  1121. decoder: "jsend"
  1122. });
  1123. subscribe( "request.error", function( settings, data, status ) {
  1124. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  1125. deepEqual( data, { message: "it broke" }, "error message: data" );
  1126. equal( status, "error", "error message: status" );
  1127. });
  1128. subscribe( "request.complete", function( settings, data, status ) {
  1129. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1130. deepEqual( data, { message: "it broke" }, "complete message: data" );
  1131. equal( status, "error", "complete message: status" );
  1132. start();
  1133. });
  1134. subscribe( "request.success", function() {
  1135. ok( false, "success message published" );
  1136. });
  1137. amplify.request({
  1138. resourceId: "test",
  1139. success: function() {
  1140. ok( false, "success callback invoked" );
  1141. },
  1142. error: function( data, status ) {
  1143. deepEqual( data, { message: "it broke" }, "error callback: data" );
  1144. equal( status, "error", "error callback: status" );
  1145. }
  1146. });
  1147. });
  1148. asyncTest( "decoder: jsend - error with details", function() {
  1149. expect( 8 );
  1150. amplify.request.define( "test", "ajax", {
  1151. url: "data/jsend-error2.json",
  1152. dataType: "json",
  1153. decoder: "jsend"
  1154. });
  1155. subscribe( "request.error", function( settings, data, status ) {
  1156. equal( settings.resourceId, "test", "error message: settings.resrouceId" );
  1157. deepEqual( data, {
  1158. message: "it broke",
  1159. code: 15,
  1160. data: { you: "broke", it: "bad" }
  1161. }, "error message: data" );
  1162. equal( status, "error", "error message: status" );
  1163. });
  1164. subscribe( "request.complete", function( settings, data, status ) {
  1165. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1166. deepEqual( data, {
  1167. message: "it broke",
  1168. code: 15,
  1169. data: { you: "broke", it: "bad" }
  1170. }, "complete message: data" );
  1171. equal( status, "error", "complete message: status" );
  1172. start();
  1173. });
  1174. subscribe( "request.success", function() {
  1175. ok( false, "success message published" );
  1176. });
  1177. amplify.request({
  1178. resourceId: "test",
  1179. success: function() {
  1180. ok( false, "success callback invoked" );
  1181. },
  1182. error: function( data, status ) {
  1183. deepEqual( data, {
  1184. message: "it broke",
  1185. code: 15,
  1186. data: { you: "broke", it: "bad" }
  1187. }, "error callback: data" );
  1188. equal( status, "error", "error callback: status" );
  1189. }
  1190. });
  1191. });
  1192. asyncTest( "decoder: custom", function() {
  1193. expect( 11 );
  1194. amplify.request.decoders.silly = function( data, status, xhr, success, error ) {
  1195. deepEqual( data, { foo: "bar" }, "data in decoder" );
  1196. equal( status, "success", "status in decoder" );
  1197. ok( "abort" in xhr, "xhr in decoder" );
  1198. var sillyData = {};
  1199. $.each( data, function( key, value ) {
  1200. sillyData[ "silly-" + key ] = value;
  1201. });
  1202. success( sillyData, "silly" );
  1203. };
  1204. amplify.request.define( "test", "ajax", {
  1205. url: "data/data.json",
  1206. dataType: "json",
  1207. decoder: "silly"
  1208. });
  1209. subscribe( "request.success", function( settings, data, status ) {
  1210. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  1211. deepEqual( data, { "silly-foo": "bar" }, "success message: data" );
  1212. equal( status, "silly", "success message: status" );
  1213. });
  1214. subscribe( "request.complete", function( settings, data, status ) {
  1215. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1216. deepEqual( data, { "silly-foo": "bar" }, "complete message: data" );
  1217. equal( status, "silly", "complete message: status" );
  1218. start();
  1219. delete amplify.request.decoders.silly;
  1220. });
  1221. subscribe( "request.error", function() {
  1222. ok( false, "error message published" );
  1223. });
  1224. amplify.request({
  1225. resourceId: "test",
  1226. success: function( data, status ) {
  1227. deepEqual( data, { "silly-foo": "bar" }, "success callback: data" );
  1228. equal( status, "silly", "success callback: status" );
  1229. },
  1230. error: function() {
  1231. ok( false, "error callback invoked" );
  1232. }
  1233. });
  1234. });
  1235. asyncTest( "decoder: jsonp", function() {
  1236. expect( 11 );
  1237. amplify.request.define( "test", "ajax", {
  1238. url: "data/jsonp.php",
  1239. dataType: "jsonp",
  1240. decoder: function( data, status, xhr, success, error ) {
  1241. deepEqual( data, { foo: "bar" }, "data in decoder" );
  1242. equal( status, "success", "status in decoder" );
  1243. ok( "abort" in xhr, "xhr in decoder" );
  1244. var decodedData = {};
  1245. $.each( data, function( key, value ) {
  1246. decodedData[ "decoded-" + key ] = value;
  1247. });
  1248. success( decodedData, "decoded-jsonp" );
  1249. }
  1250. });
  1251. subscribe( "request.success", function( settings, data, status ) {
  1252. equal( settings.resourceId, "test", "success message: settings.resrouceId" );
  1253. deepEqual( data, { "decoded-foo": "bar" }, "success message: data" );
  1254. equal( status, "decoded-jsonp", "success message: status" );
  1255. });
  1256. subscribe( "request.complete", function( settings, data, status ) {
  1257. equal( settings.resourceId, "test", "complete message: settings.resrouceId" );
  1258. deepEqual( data, { "decoded-foo": "bar" }, "complete message: data" );
  1259. equal( status, "decoded-jsonp", "complete message: status" );
  1260. start();
  1261. });
  1262. subscribe( "request.error", function() {
  1263. ok( false, "error message published" );
  1264. });
  1265. amplify.request({
  1266. resourceId: "test",
  1267. success: function( data, status ) {
  1268. deepEqual( data, { "decoded-foo": "bar" }, "success callback: data" );
  1269. equal( status, "decoded-jsonp", "success callback: status" );
  1270. },
  1271. error: function() {
  1272. ok( false, "error callback invoked" );
  1273. }
  1274. });
  1275. });
  1276. }());