← Back to branch summary

~tsep-dev/tsep/0.9-beta

« back to all changes in this revision

Viewing changes to branches/symfony/cake/tests/cases/libs/view/helpers/mootools_engine.test.php

  • Committer: geoffreyfishing
  • Date: 2011-01-11 23:46:12 UTC
  • Revision ID: svn-v4:ae0de26e-ed09-4cbe-9a20-e40b4c60ac6c::125
Created a symfony branch for future migration to symfony

Show diffs side-by-side

added added

removed removed

Lines of Context:
branches/symfony/cake/tests/cases/libs/view/helpers/mootools_engine.test.php
 
1
<?php
 
2
/**
 
3
 * MooEngineTestCase
 
4
 *
 
5
 *
 
6
 *
 
7
 * PHP versions 4 and 5
 
8
 *
 
9
 * CakePHP : Rapid Development Framework <http://www.cakephp.org/>
 
10
 * Copyright 2006-2009, Cake Software Foundation, Inc.
 
11
 *                                                              1785 E. Sahara Avenue, Suite 490-204
 
12
 *                                                              Las Vegas, Nevada 89104
 
13
 *
 
14
 * Licensed under The MIT License
 
15
 * Redistributions of files must retain the above copyright notice.
 
16
 *
 
17
 * @copyright       Copyright 2006-2009, Cake Software Foundation, Inc.
 
18
 * @link            http://cakephp.org CakePHP Project
 
19
 * @package         cake.tests
 
20
 * @subpackage      cake.tests.cases.views.helpers
 
21
 * @license         MIT License (http://www.opensource.org/licenses/mit-license.php)
 
22
 */
 
23
App::import('Helper', array('Html', 'Js', 'MootoolsEngine'));
 
24
 
 
25
class MooEngineHelperTestCase extends CakeTestCase {
 
26
/**
 
27
 * startTest
 
28
 *
 
29
 * @return void
 
30
 */
 
31
        function startTest() {
 
32
                $this->Moo =& new MootoolsEngineHelper();
 
33
        }
 
34
/**
 
35
 * end test
 
36
 *
 
37
 * @return void
 
38
 */
 
39
        function endTest() {
 
40
                unset($this->Moo);
 
41
        }
 
42
/**
 
43
 * test selector method
 
44
 *
 
45
 * @return void
 
46
 */
 
47
        function testSelector() {
 
48
                $result = $this->Moo->get('#content');
 
49
                $this->assertEqual($result, $this->Moo);
 
50
                $this->assertEqual($this->Moo->selection, '$("content")');
 
51
 
 
52
                $result = $this->Moo->get('a .remove');
 
53
                $this->assertEqual($result, $this->Moo);
 
54
                $this->assertEqual($this->Moo->selection, '$$("a .remove")');
 
55
 
 
56
                $result = $this->Moo->get('document');
 
57
                $this->assertEqual($result, $this->Moo);
 
58
                $this->assertEqual($this->Moo->selection, "$(document)");
 
59
 
 
60
                $result = $this->Moo->get('window');
 
61
                $this->assertEqual($result, $this->Moo);
 
62
                $this->assertEqual($this->Moo->selection, "$(window)");
 
63
 
 
64
                $result = $this->Moo->get('ul');
 
65
                $this->assertEqual($result, $this->Moo);
 
66
                $this->assertEqual($this->Moo->selection, '$$("ul")');
 
67
 
 
68
                $result = $this->Moo->get('#some_long-id.class');
 
69
                $this->assertEqual($result, $this->Moo);
 
70
                $this->assertEqual($this->Moo->selection, '$$("#some_long-id.class")');
 
71
        }
 
72
/**
 
73
 * test event binding
 
74
 *
 
75
 * @return void
 
76
 */
 
77
        function testEvent() {
 
78
                $this->Moo->get('#myLink');
 
79
                $result = $this->Moo->event('click', 'doClick', array('wrap' => false));
 
80
                $expected = '$("myLink").addEvent("click", doClick);';
 
81
                $this->assertEqual($result, $expected);
 
82
 
 
83
                $result = $this->Moo->event('click', 'this.setStyle("display", "");', array('stop' => false));
 
84
                $expected = '$("myLink").addEvent("click", function (event) {this.setStyle("display", "");});';
 
85
                $this->assertEqual($result, $expected);
 
86
 
 
87
                $result = $this->Moo->event('click', 'this.setStyle("display", "none");');
 
88
                $expected = "\$(\"myLink\").addEvent(\"click\", function (event) {event.stop();\nthis.setStyle(\"display\", \"none\");});";
 
89
                $this->assertEqual($result, $expected);
 
90
        }
 
91
/**
 
92
 * test dom ready event creation
 
93
 *
 
94
 * @return void
 
95
 */
 
96
        function testDomReady() {
 
97
                $result = $this->Moo->domReady('foo.name = "bar";');
 
98
                $expected = 'window.addEvent("domready", function (event) {foo.name = "bar";});';
 
99
                $this->assertEqual($result, $expected);
 
100
        }
 
101
/**
 
102
 * test Each method
 
103
 *
 
104
 * @return void
 
105
 */
 
106
        function testEach() {
 
107
                $this->Moo->get('#foo');
 
108
                $result = $this->Moo->each('item.setStyle("display", "none");');
 
109
                $expected = '$("foo").each(function (item, index) {item.setStyle("display", "none");});';
 
110
                $this->assertEqual($result, $expected);
 
111
        }
 
112
/**
 
113
 * test Effect generation
 
114
 *
 
115
 * @return void
 
116
 */
 
117
        function testEffect() {
 
118
                $this->Moo->get('#foo');
 
119
                $result = $this->Moo->effect('show');
 
120
                $expected = '$("foo").setStyle("display", "");';
 
121
                $this->assertEqual($result, $expected);
 
122
 
 
123
                $result = $this->Moo->effect('hide');
 
124
                $expected = '$("foo").setStyle("display", "none");';
 
125
                $this->assertEqual($result, $expected);
 
126
 
 
127
                $result = $this->Moo->effect('fadeIn');
 
128
                $expected = '$("foo").fade("in");';
 
129
                $this->assertEqual($result, $expected);
 
130
 
 
131
                $result = $this->Moo->effect('fadeOut');
 
132
                $expected = '$("foo").fade("out");';
 
133
                $this->assertEqual($result, $expected);
 
134
 
 
135
                $result = $this->Moo->effect('slideIn');
 
136
                $expected = '$("foo").slide("in");';
 
137
                $this->assertEqual($result, $expected);
 
138
 
 
139
                $result = $this->Moo->effect('slideOut');
 
140
                $expected = '$("foo").slide("out");';
 
141
                $this->assertEqual($result, $expected);
 
142
 
 
143
                $result = $this->Moo->effect('slideOut', array('speed' => 'fast'));
 
144
                $expected = '$("foo").set("slide", {duration:"short"}).slide("out");';
 
145
                $this->assertEqual($result, $expected);
 
146
 
 
147
                $result = $this->Moo->effect('slideOut', array('speed' => 'slow'));
 
148
                $expected = '$("foo").set("slide", {duration:"long"}).slide("out");';
 
149
                $this->assertEqual($result, $expected);
 
150
        }
 
151
/**
 
152
 * Test Request Generation
 
153
 *
 
154
 * @return void
 
155
 */
 
156
        function testRequest() {
 
157
                $result = $this->Moo->request(array('controller' => 'posts', 'action' => 'view', 1));
 
158
                $expected = 'var jsRequest = new Request({url:"\\/posts\\/view\\/1"}).send();';
 
159
                $this->assertEqual($result, $expected);
 
160
 
 
161
                $result = $this->Moo->request('/posts/view/1', array('update' => 'content'));
 
162
                $expected = 'var jsRequest = new Request.HTML({update:"content", url:"\\/posts\\/view\\/1"}).send();';
 
163
                $this->assertEqual($result, $expected);
 
164
 
 
165
                $result = $this->Moo->request('/people/edit/1', array(
 
166
                        'method' => 'post',
 
167
                        'complete' => 'doSuccess',
 
168
                        'error' => 'handleError',
 
169
                        'type' => 'json',
 
170
                        'data' => array('name' => 'jim', 'height' => '185cm'),
 
171
                        'wrapCallbacks' => false
 
172
                ));
 
173
                $expected = 'var jsRequest = new Request.JSON({method:"post", onComplete:doSuccess, onFailure:handleError, url:"\\/people\\/edit\\/1"}).send({"name":"jim","height":"185cm"});';
 
174
                $this->assertEqual($result, $expected);
 
175
 
 
176
                $result = $this->Moo->request('/people/edit/1', array(
 
177
                        'method' => 'post',
 
178
                        'complete' => 'doSuccess',
 
179
                        'update' => '#update-zone',
 
180
                        'wrapCallbacks' => false
 
181
                ));
 
182
                $expected = 'var jsRequest = new Request.HTML({method:"post", onComplete:doSuccess, update:"update-zone", url:"\\/people\\/edit\\/1"}).send();';
 
183
                $this->assertEqual($result, $expected);
 
184
 
 
185
                $result = $this->Moo->request('/people/edit/1', array(
 
186
                        'method' => 'post',
 
187
                        'complete' => 'doComplete',
 
188
                        'success' => 'doSuccess',
 
189
                        'error' => 'doFailure',
 
190
                        'before' => 'doBefore',
 
191
                        'update' => 'update-zone',
 
192
                        'wrapCallbacks' => false
 
193
                ));
 
194
                $expected = 'var jsRequest = new Request.HTML({method:"post", onComplete:doComplete, onFailure:doFailure, onRequest:doBefore, onSuccess:doSuccess, update:"update-zone", url:"\\/people\\/edit\\/1"}).send();';
 
195
                $this->assertEqual($result, $expected);
 
196
 
 
197
                $result = $this->Moo->request('/people/edit/1', array(
 
198
                        'method' => 'post',
 
199
                        'complete' => 'doComplete',
 
200
                        'success' => 'doSuccess',
 
201
                        'error' => 'doFailure',
 
202
                        'before' => 'doBefore',
 
203
                        'update' => 'update-zone',
 
204
                        'dataExpression' => true,
 
205
                        'data' => '$("foo").toQueryString()',
 
206
                        'wrapCallbacks' => false
 
207
                ));
 
208
                $expected = 'var jsRequest = new Request.HTML({method:"post", onComplete:doComplete, onFailure:doFailure, onRequest:doBefore, onSuccess:doSuccess, update:"update-zone", url:"\\/people\\/edit\\/1"}).send($("foo").toQueryString());';
 
209
                $this->assertEqual($result, $expected);
 
210
 
 
211
                $result = $this->Moo->request('/people/edit/1', array(
 
212
                        'method' => 'post',
 
213
                        'before' => 'doBefore',
 
214
                        'success' => 'doSuccess',
 
215
                        'complete' => 'doComplete',
 
216
                        'update' => '#update-zone',
 
217
                ));
 
218
                $expected = 'var jsRequest = new Request.HTML({method:"post", onComplete:function () {doComplete}, onRequest:function () {doBefore}, onSuccess:function (responseText, responseXML) {doSuccess}, update:"update-zone", url:"\\/people\\/edit\\/1"}).send();';
 
219
                $this->assertEqual($result, $expected);
 
220
        }
 
221
/**
 
222
 * test sortable list generation
 
223
 *
 
224
 * @return void
 
225
 */
 
226
        function testSortable() {
 
227
                $this->Moo->get('#myList');
 
228
                $result = $this->Moo->sortable(array(
 
229
                        'distance' => 5,
 
230
                        'containment' => 'parent',
 
231
                        'start' => 'onStart',
 
232
                        'complete' => 'onStop',
 
233
                        'sort' => 'onSort',
 
234
                        'wrapCallbacks' => false
 
235
                ));
 
236
                $expected = 'var jsSortable = new Sortables($("myList"), {constrain:"parent", onComplete:onStop, onSort:onSort, onStart:onStart, snap:5});';
 
237
                $this->assertEqual($result, $expected);
 
238
        }
 
239
/**
 
240
 * test drag() method
 
241
 *
 
242
 * @return void
 
243
 */
 
244
        function testDrag() {
 
245
                $this->Moo->get('#drag-me');
 
246
                $result = $this->Moo->drag(array(
 
247
                        'start' => 'onStart',
 
248
                        'drag' => 'onDrag',
 
249
                        'stop' => 'onStop',
 
250
                        'snapGrid' => array(10,10),
 
251
                        'wrapCallbacks' => false
 
252
                ));
 
253
                $expected = '$("drag-me").makeDraggable({onComplete:onStop, onDrag:onDrag, onStart:onStart, snap:[10,10]});';
 
254
                $this->assertEqual($result, $expected);
 
255
        }
 
256
/**
 
257
 * test drop() method
 
258
 *
 
259
 * @return void
 
260
 */
 
261
        function testDrop() {
 
262
                $this->expectError();
 
263
                $this->Moo->get('#drop-me');
 
264
                $this->Moo->drop(array(
 
265
                        'drop' => 'onDrop',
 
266
                        'leave' => 'onLeave',
 
267
                        'hover' => 'onHover',
 
268
                ));
 
269
 
 
270
                $result = $this->Moo->drop(array(
 
271
                        'drop' => 'onDrop',
 
272
                        'leave' => 'onLeave',
 
273
                        'hover' => 'onHover',
 
274
                        'drag' => '#my-drag',
 
275
                        'wrapCallbacks' => false
 
276
                ));
 
277
                $expected = '$("my-drag").makeDraggable({droppables:$("drop-me"), onDrop:onDrop, onEnter:onHover, onLeave:onLeave});';
 
278
                $this->assertEqual($result, $expected);
 
279
                $this->assertEqual($this->Moo->selection, '$("drop-me")');
 
280
 
 
281
                $result = $this->Moo->drop(array(
 
282
                        'drop' => 'onDrop',
 
283
                        'leave' => 'onLeave',
 
284
                        'hover' => 'onHover',
 
285
                        'drag' => '#my-drag',
 
286
                ));
 
287
                $expected = '$("my-drag").makeDraggable({droppables:$("drop-me"), onDrop:function (element, droppable, event) {onDrop}, onEnter:function (element, droppable) {onHover}, onLeave:function (element, droppable) {onLeave}});';
 
288
                $this->assertEqual($result, $expected);
 
289
        }
 
290
/**
 
291
 * test slider generation
 
292
 *
 
293
 * @return void
 
294
 */
 
295
        function testSlider() {
 
296
                $this->Moo->get('#slider');
 
297
                $result = $this->Moo->slider(array(
 
298
                        'handle' => '#my-handle',
 
299
                        'complete' => 'onComplete',
 
300
                        'change' => 'onChange',
 
301
                        'direction' => 'horizontal',
 
302
                        'wrapCallbacks' => false
 
303
                ));
 
304
                $expected = 'var jsSlider = new Slider($("slider"), $("my-handle"), {mode:"horizontal", onChange:onChange, onComplete:onComplete});';
 
305
                $this->assertEqual($result, $expected);
 
306
                $this->assertEqual($this->Moo->selection, '$("slider")');
 
307
 
 
308
                $this->Moo->get('#slider');
 
309
                $result = $this->Moo->slider(array(
 
310
                        'handle' => '#my-handle',
 
311
                        'complete' => 'onComplete',
 
312
                        'change' => 'onChange',
 
313
                        'direction' => 'horizontal',
 
314
                        'min' => 10,
 
315
                        'max' => 40,
 
316
                        'wrapCallbacks' => false
 
317
                ));
 
318
                $expected = 'var jsSlider = new Slider($("slider"), $("my-handle"), {mode:"horizontal", onChange:onChange, onComplete:onComplete, range:[10,40]});';
 
319
                $this->assertEqual($result, $expected);
 
320
 
 
321
                $this->Moo->get('#slider');
 
322
                $result = $this->Moo->slider(array(
 
323
                        'handle' => '#my-handle',
 
324
                        'complete' => 'complete;',
 
325
                        'change' => 'change;',
 
326
                        'direction' => 'horizontal',
 
327
                ));
 
328
                $expected = 'var jsSlider = new Slider($("slider"), $("my-handle"), {mode:"horizontal", onChange:function (step) {change;}, onComplete:function (event) {complete;}});';
 
329
                $this->assertEqual($result, $expected);
 
330
        }
 
331
/**
 
332
 * test the serializeForm implementation.
 
333
 *
 
334
 * @return void
 
335
 */
 
336
        function testSerializeForm() {
 
337
                $this->Moo->get('#element');
 
338
                $result = $this->Moo->serializeForm(array('isForm' => true));
 
339
                $expected = '$("element").toQueryString();';
 
340
                $this->assertEqual($result, $expected);
 
341
 
 
342
                $result = $this->Moo->serializeForm(array('isForm' => true, 'inline' => true));
 
343
                $expected = '$("element").toQueryString()';
 
344
                $this->assertEqual($result, $expected);
 
345
 
 
346
                $result = $this->Moo->serializeForm(array('isForm' => false));
 
347
                $expected = '$($("element").form).toQueryString();';
 
348
                $this->assertEqual($result, $expected);
 
349
 
 
350
                $result = $this->Moo->serializeForm(array('isForm' => false, 'inline' => true));
 
351
                $expected = '$($("element").form).toQueryString()';
 
352
                $this->assertEqual($result, $expected);
 
353
        }
 
354
}