← Back to branch summary

~lutostag/ubuntu/utopic/maas/1.5.2

« back to all changes in this revision

Viewing changes to src/maasserver/static/jslibs/yui/3.4.1/tests/slider/tests/src/slider.js

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2012-03-15 18:14:08 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20120315181408-zgl94hzo0x4n99an
Tags: 0.1+bzr295+dfsg-0ubuntu2
* debian/patches:
  - 01-fix-database-settings.patch: Update to set PSERV_URL.
  - 02-pserv-config.patch: Set port to 8001.
* debian/maas.postinst: Run maas-import-isos on install.
* debian/control: Depends on rabbitmq-server.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/jslibs/yui/3.4.1/tests/slider/tests/src/slider.js
 
1
var suite = new Y.Test.Suite("Y.Slider");
 
2
 
 
3
suite.add( new Y.Test.Case({
 
4
    name: "Lifecycle",
 
5
 
 
6
    setUp: function () {
 
7
        Y.one("body").append('<div id="testbed"></div>');
 
8
    },
 
9
 
 
10
    tearDown: function () {
 
11
        Y.one("#testbed").remove(true);
 
12
    },
 
13
 
 
14
    "test default construction": function () {
 
15
        Y.Assert.isInstanceOf( Y.Slider, new Y.Slider() );
 
16
    },
 
17
 
 
18
    "test SliderBase construction": function () {
 
19
        Y.Assert.isInstanceOf( Y.SliderBase, new Y.SliderBase() );
 
20
    },
 
21
 
 
22
    "test render(selector)": function () {
 
23
        Y.one("#testbed").setContent(
 
24
            "<div></div>" +   // block element
 
25
            '<div class="floated" style="float:left"></div>' + // float
 
26
            "<p></p>" +       // limited block element
 
27
            "<span></span>"); // inline element
 
28
 
 
29
        (new Y.Slider().render("#testbed > div"));
 
30
        (new Y.Slider().render("#testbed > div.floated"));
 
31
        (new Y.Slider().render("#testbed > p"));
 
32
        (new Y.Slider().render("#testbed > span"));
 
33
 
 
34
        var div  = Y.one("#testbed > div"),
 
35
            fl   = Y.one("#testbed > div.floated"),
 
36
            p    = Y.one("#testbed > p"),
 
37
            span = Y.one("#testbed > span");
 
38
 
 
39
        Y.assert( (div.get("offsetHeight") > 0) );
 
40
        Y.assert( (fl.get("offsetHeight") > 0) );
 
41
        Y.assert( (p.get("offsetHeight") > 0) );
 
42
        Y.assert( (span.get("offsetHeight") > 0) );
 
43
 
 
44
        Y.assert( (fl.get("offsetWidth") > 0) );
 
45
        Y.assert( (span.get("offsetWidth") > 0) );
 
46
 
 
47
        Y.Assert.areEqual( 8, div.all("span,img").size() );
 
48
        Y.Assert.areEqual( 8, fl.all("span,img").size() );
 
49
        Y.Assert.areEqual( 8, p.all("span,img").size() );
 
50
        Y.Assert.areEqual( 8, span.all("span,img").size() );
 
51
    },
 
52
 
 
53
    "test render( node )": function () {
 
54
        Y.one("#testbed").setContent(
 
55
            "<div></div>" +   // block element
 
56
            '<div class="floated" style="float:left"></div>' + // float
 
57
            "<p></p>" +       // limited block element
 
58
            "<span></span>"); // inline element
 
59
 
 
60
        var div  = Y.one("#testbed > div"),
 
61
            fl   = Y.one("#testbed > div.floated"),
 
62
            p    = Y.one("#testbed > p"),
 
63
            span = Y.one("#testbed > span");
 
64
 
 
65
        (new Y.Slider().render(div));
 
66
        (new Y.Slider().render(fl));
 
67
        (new Y.Slider().render(p));
 
68
        (new Y.Slider().render(span));
 
69
 
 
70
        Y.assert( (div.get("offsetHeight") > 0) );
 
71
        Y.assert( (fl.get("offsetHeight") > 0) );
 
72
        Y.assert( (p.get("offsetHeight") > 0) );
 
73
        Y.assert( (span.get("offsetHeight") > 0) );
 
74
 
 
75
        Y.assert( (fl.get("offsetWidth") > 0) );
 
76
        Y.assert( (span.get("offsetWidth") > 0) );
 
77
 
 
78
        Y.Assert.areEqual( 8, div.all("span,img").size() );
 
79
        Y.Assert.areEqual( 8, fl.all("span,img").size() );
 
80
        Y.Assert.areEqual( 8, p.all("span,img").size() );
 
81
        Y.Assert.areEqual( 8, span.all("span,img").size() );
 
82
    },
 
83
 
 
84
    "test render: selector attrib in constructor": function () {
 
85
        Y.one("#testbed").setContent(
 
86
            "<div></div>" +   // block element
 
87
            '<div class="floated" style="float:left"></div>' + // float
 
88
            "<p></p>" +       // limited block element
 
89
            "<span></span>"); // inline element
 
90
 
 
91
        (new Y.Slider({ render: "#testbed > div" }));
 
92
        (new Y.Slider({ render: "#testbed > div.floated" }));
 
93
        (new Y.Slider({ render: "#testbed > p" }));
 
94
        (new Y.Slider({ render: "#testbed > span" }));
 
95
 
 
96
        var div  = Y.one("#testbed > div"),
 
97
            fl   = Y.one("#testbed > div.floated"),
 
98
            p    = Y.one("#testbed > p"),
 
99
            span = Y.one("#testbed > span");
 
100
 
 
101
        Y.assert( (div.get("offsetHeight") > 0) );
 
102
        Y.assert( (fl.get("offsetHeight") > 0) );
 
103
        Y.assert( (p.get("offsetHeight") > 0) );
 
104
        Y.assert( (span.get("offsetHeight") > 0) );
 
105
 
 
106
        Y.assert( (fl.get("offsetWidth") > 0) );
 
107
        Y.assert( (span.get("offsetWidth") > 0) );
 
108
 
 
109
        Y.Assert.areEqual( 8, div.all("span,img").size() );
 
110
        Y.Assert.areEqual( 8, fl.all("span,img").size() );
 
111
        Y.Assert.areEqual( 8, p.all("span,img").size() );
 
112
        Y.Assert.areEqual( 8, span.all("span,img").size() );
 
113
    },
 
114
 
 
115
    "test render: node attrib in constructor": function () {
 
116
        Y.one("#testbed").setContent(
 
117
            "<div></div>" +   // block element
 
118
            '<div class="floated" style="float:left"></div>' + // float
 
119
            "<p></p>" +       // limited block element
 
120
            "<span></span>"); // inline element
 
121
 
 
122
        var div  = Y.one("#testbed > div"),
 
123
            fl   = Y.one("#testbed > div.floated"),
 
124
            p    = Y.one("#testbed > p"),
 
125
            span = Y.one("#testbed > span");
 
126
 
 
127
        (new Y.Slider({ render: div }));
 
128
        (new Y.Slider({ render: fl }));
 
129
        (new Y.Slider({ render: p }));
 
130
        (new Y.Slider({ render: span }));
 
131
 
 
132
        Y.assert( (div.get("offsetHeight") > 0) );
 
133
        Y.assert( (fl.get("offsetHeight") > 0) );
 
134
        Y.assert( (p.get("offsetHeight") > 0) );
 
135
        Y.assert( (span.get("offsetHeight") > 0) );
 
136
 
 
137
        Y.assert( (fl.get("offsetWidth") > 0) );
 
138
        Y.assert( (span.get("offsetWidth") > 0) );
 
139
 
 
140
        Y.Assert.areEqual( 8, div.all("span,img").size() );
 
141
        Y.Assert.areEqual( 8, fl.all("span,img").size() );
 
142
        Y.Assert.areEqual( 8, p.all("span,img").size() );
 
143
        Y.Assert.areEqual( 8, span.all("span,img").size() );
 
144
    },
 
145
 
 
146
    "test render off DOM": function () {
 
147
        var container = Y.Node.create("<div></div>");
 
148
 
 
149
        (new Y.Slider().render(container));
 
150
 
 
151
        Y.Assert.areEqual( 8, container.all("span,img").size() );
 
152
    },
 
153
 
 
154
    "test destroy() before render": function () {
 
155
        var slider = new Y.Slider();
 
156
 
 
157
        slider.destroy();
 
158
 
 
159
        Y.Assert.isTrue( slider.get("destroyed") );
 
160
    },
 
161
 
 
162
    "test destroy() after render off DOM": function () {
 
163
        var container = Y.Node.create("<div></div>"),
 
164
            slider = new Y.Slider();
 
165
 
 
166
        slider.render( container );
 
167
 
 
168
        slider.destroy();
 
169
 
 
170
        Y.Assert.isTrue( slider.get("destroyed") );
 
171
 
 
172
        Y.Assert.isNull( container.get("firstChild") );
 
173
    },
 
174
 
 
175
    "test destroy() after render to DOM": function () {
 
176
        var slider = new Y.Slider();
 
177
 
 
178
        slider.render( "#testbed" );
 
179
 
 
180
        slider.destroy();
 
181
 
 
182
        Y.Assert.isTrue( slider.get("destroyed") );
 
183
 
 
184
        Y.Assert.isNull( Y.one("#testbed").get("firstChild") );
 
185
    }
 
186
}));
 
187
 
 
188
suite.add( new Y.Test.Case({
 
189
    name: "API",
 
190
 
 
191
    setUp: function () {
 
192
        Y.one('body').append('<div id="testbed"></div>');
 
193
 
 
194
        this.slider = new Y.Slider();
 
195
    },
 
196
 
 
197
    tearDown: function () {
 
198
        this.slider.destroy();
 
199
 
 
200
        Y.one('#testbed').remove(true);
 
201
    },
 
202
 
 
203
    "test getValue() and setValue(v) before render": function () {
 
204
        var s = this.slider;
 
205
 
 
206
        Y.Assert.areEqual( 0, s.getValue() );
 
207
 
 
208
        s.setValue(50);
 
209
        Y.Assert.areEqual( 50, s.getValue() );
 
210
 
 
211
        s.setValue(3.3333);
 
212
        Y.Assert.areEqual( 3, s.getValue() );
 
213
 
 
214
        // out of range constrained by setter
 
215
        s.setValue(-10);
 
216
        Y.Assert.areEqual( 0, s.getValue() );
 
217
 
 
218
        s.setValue(110);
 
219
        Y.Assert.areEqual( 100, s.getValue() );
 
220
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
221
 
 
222
        s.set('value', 6.66666);
 
223
        Y.Assert.areEqual( 7, s.getValue() );
 
224
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
225
    },
 
226
 
 
227
    "test getValue() and setValue(v) after render() to hidden container": function () {
 
228
        var container = Y.Node.create('<div></div>'),
 
229
            s = this.slider;
 
230
 
 
231
        s.render( container );
 
232
 
 
233
        Y.Assert.areEqual( 0, s.getValue() );
 
234
 
 
235
        s.setValue(50);
 
236
        Y.Assert.areEqual( 50, s.getValue() );
 
237
 
 
238
        s.setValue(3.3333);
 
239
        Y.Assert.areEqual( 3, s.getValue() );
 
240
 
 
241
        s.setValue(-10);
 
242
        Y.Assert.areEqual( 0, s.getValue() );
 
243
 
 
244
        s.setValue(110);
 
245
        Y.Assert.areEqual( 100, s.getValue() );
 
246
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
247
 
 
248
        s.set('value', 6.66666);
 
249
        Y.Assert.areEqual( 7, s.getValue() );
 
250
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
251
    },
 
252
 
 
253
    "test getValue() and setValue(v) after render() to DOM": function () {
 
254
        var s = this.slider;
 
255
 
 
256
        s.render('#testbed');
 
257
 
 
258
        Y.Assert.areEqual( 0, s.getValue() );
 
259
 
 
260
        s.setValue(50);
 
261
        Y.Assert.areEqual( 50, s.getValue() );
 
262
 
 
263
        s.setValue(3.3333);
 
264
        Y.Assert.areEqual( 3, s.getValue() );
 
265
 
 
266
        s.setValue(-10);
 
267
        Y.Assert.areEqual( 0, s.getValue() );
 
268
 
 
269
        s.setValue(110);
 
270
        Y.Assert.areEqual( 100, s.getValue() );
 
271
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
272
 
 
273
        s.set('value', 6.66666);
 
274
        Y.Assert.areEqual( 7, s.getValue() );
 
275
        Y.Assert.areEqual( s.get('value'), s.getValue() );
 
276
    },
 
277
 
 
278
    "setValue(v) then render() should position thumb": function () {
 
279
        var s = this.slider;
 
280
 
 
281
        s.setValue(20);
 
282
        s.render("#testbed");
 
283
 
 
284
        Y.Assert.areEqual( 27, parseInt(s.thumb.getStyle("left"),10) );
 
285
    },
 
286
 
 
287
    "setValue(v) after render() should move the thumb": function () {
 
288
        var s = this.slider;
 
289
 
 
290
        s.render('#testbed');
 
291
 
 
292
        Y.Assert.areEqual( 0, parseInt(s.thumb.getStyle('left'),10) );
 
293
 
 
294
        s.setValue(20);
 
295
        Y.Assert.areEqual( 27, parseInt(s.thumb.getStyle('left'),10) );
 
296
 
 
297
        s.setValue(0);
 
298
        Y.Assert.areEqual( 0, s.getValue() );
 
299
        Y.Assert.areEqual( 0, parseInt(s.thumb.getStyle('left'),10) );
 
300
 
 
301
        s.setValue(100);
 
302
        Y.Assert.areEqual( 100, s.getValue() );
 
303
        Y.Assert.areEqual( 135, parseInt(s.thumb.getStyle('left'),10) );
 
304
    },
 
305
 
 
306
    "setValue(v) when hidden should still move the thumb": function () {
 
307
        var s = this.slider;
 
308
 
 
309
        Y.one('#testbed').setStyle('display','none');
 
310
 
 
311
        s.render('#testbed');
 
312
 
 
313
        Y.Assert.areEqual( 0, parseInt(s.thumb.getStyle('left'),10) );
 
314
 
 
315
        s.setValue(20);
 
316
        Y.Assert.areEqual( 27, parseInt(s.thumb.getStyle('left'),10) );
 
317
 
 
318
 
 
319
        Y.one('#testbed').setStyle('display','');
 
320
        Y.Assert.areEqual( 27, parseInt(s.thumb.getStyle('left'),10) );
 
321
    }
 
322
}));
 
323
 
 
324
suite.add( new Y.Test.Case({
 
325
    name: "Attributes",
 
326
 
 
327
    _should: {
 
328
        fail: {
 
329
            // TODO This is a bug. invalid construction value should fallback
 
330
            // to specified attribute default
 
331
            "axis should only accept 'x', 'X', 'y', and 'Y'": true
 
332
        }
 
333
    },
 
334
 
 
335
    setUp: function () {
 
336
        Y.one('body').append('<span id="testbed"></span>');
 
337
    },
 
338
 
 
339
    tearDown: function () {
 
340
        Y.one('#testbed').remove(true);
 
341
    },
 
342
 
 
343
    "test axis": function () {
 
344
        var testbed = Y.one('#testbed'),
 
345
            slider = new Y.Slider({ axis: 'x' }).render( testbed ),
 
346
            bb = testbed.get("firstChild");
 
347
 
 
348
        Y.assert( (bb.get("offsetWidth") > 100), "offsetWidth > 100" );
 
349
        Y.assert( (bb.get("offsetHeight") < 50), "offsetHeight < 50" );
 
350
 
 
351
        slider.destroy();
 
352
 
 
353
        slider = new Y.Slider({ axis: 'y' }).render( testbed );
 
354
        bb = testbed.get("firstChild");
 
355
 
 
356
        Y.assert( (bb.get("offsetHeight") > 100), "offsetHeight > 100" );
 
357
        Y.assert( (bb.get("offsetWidth") < 50), "offsetWidth < 50" );
 
358
 
 
359
        slider.destroy();
 
360
    },
 
361
 
 
362
    "axis should be writeOnce": function () {
 
363
        var slider = new Y.Slider();
 
364
 
 
365
        Y.Assert.areEqual("x", slider.get("axis"));
 
366
 
 
367
        slider.set('axis', 'y');
 
368
        Y.Assert.areEqual("x", slider.get("axis"));
 
369
 
 
370
        slider.destroy();
 
371
 
 
372
        slider = new Y.Slider({ axis: 'y' });
 
373
        Y.Assert.areEqual("y", slider.get("axis"));
 
374
 
 
375
        slider.set('axis', 'x');
 
376
        Y.Assert.areEqual("y", slider.get("axis"));
 
377
    },
 
378
 
 
379
    "axis should only accept 'x', 'X', 'y', and 'Y'": function () {
 
380
        var attempts = "a b c 1 2 3 yx yy YX YY vertical vert eks".split(/ /);
 
381
 
 
382
        Y.each( attempts, function ( axis ) {
 
383
            var slider = new Y.Slider({ axis: axis });
 
384
            Y.Assert.areEqual("x", slider.get("axis"));
 
385
            slider.destroy();
 
386
        });
 
387
 
 
388
        attempts = ['y', 'Y'];
 
389
        Y.each( attempts, function ( axis ) {
 
390
            var slider = new Y.Slider({ axis: axis });
 
391
            Y.Assert.areEqual("y", slider.get("axis"));
 
392
            slider.destroy();
 
393
        });
 
394
    },
 
395
 
 
396
    "test length": function () {
 
397
        Y.one('#testbed').append('<div id="slider"></div><div id="ref"></div>');
 
398
 
 
399
        var testbed = Y.one("#slider"),
 
400
            ref     = Y.one("#ref"),
 
401
            slider, delta, bb;
 
402
 
 
403
        slider = new Y.Slider().render( testbed );
 
404
        bb = testbed.get('firstChild');
 
405
 
 
406
        delta = bb.get('offsetWidth') - parseInt(slider.get('length'), 10);
 
407
 
 
408
        slider.destroy();
 
409
 
 
410
        slider = new Y.Slider({ length: 50 }).render( testbed );
 
411
        bb = testbed.get('firstChild');
 
412
 
 
413
        Y.Assert.areEqual( (50 + delta), bb.get('offsetWidth') );
 
414
 
 
415
        slider.set('length', 300);
 
416
        Y.Assert.areEqual( (300 + delta), bb.get('offsetWidth') );
 
417
 
 
418
        slider.set('length', "-140px");
 
419
        Y.Assert.areEqual( (300 + delta), bb.get('offsetWidth') );
 
420
 
 
421
        ref.setStyle("width", "23.5em");
 
422
        slider.set('length', '23.5em');
 
423
        Y.Assert.areEqual( (ref.get('offsetWidth') + delta), bb.get('offsetWidth') );
 
424
 
 
425
        slider.destroy();
 
426
 
 
427
        slider = new Y.Slider({ axis: 'y' }).render( testbed );
 
428
        bb = testbed.get('firstChild');
 
429
 
 
430
        delta = bb.get('offsetHeight') - parseInt(slider.get('length'), 10);
 
431
 
 
432
        slider.destroy();
 
433
 
 
434
        slider = new Y.Slider({ axis: 'y', length: 50 }).render( testbed );
 
435
        bb = testbed.get('firstChild');
 
436
 
 
437
        Y.Assert.areEqual( (50 + delta), bb.get('offsetHeight') );
 
438
 
 
439
        slider.set('length', 300);
 
440
        Y.Assert.areEqual( (300 + delta), bb.get('offsetHeight') );
 
441
 
 
442
        slider.set('length', "-140px");
 
443
        Y.Assert.areEqual( (300 + delta), bb.get('offsetHeight') );
 
444
 
 
445
        ref.setStyle("height", "23.5em");
 
446
        slider.set('length', '23.5em');
 
447
        Y.Assert.areEqual( (ref.get('offsetHeight') + delta), bb.get('offsetHeight') );
 
448
    },
 
449
 
 
450
    "thumbUrl should default at render()": function () {
 
451
        var slider = new Y.Slider();
 
452
        
 
453
        Y.Assert.isNull( slider.get('thumbUrl') );
 
454
        
 
455
        slider.render('#testbed');
 
456
 
 
457
        Y.Assert.isString( slider.get('thumbUrl') );
 
458
 
 
459
        slider.destroy();
 
460
    },
 
461
 
 
462
    "thumbUrl should default to sam skin": function () {
 
463
        var slider = new Y.Slider().render("#testbed");
 
464
 
 
465
        Y.Assert.areEqual( Y.config.base + 'slider-base/assets/skins/sam/thumb-x.png', slider.get('thumbUrl') );
 
466
 
 
467
        slider.destroy();
 
468
    },
 
469
 
 
470
    "thumbUrl should default from the current skin": function () {
 
471
        var testbed = Y.one("#testbed"),
 
472
            slider  = new Y.Slider();
 
473
 
 
474
        testbed.addClass("yui3-skin-foo");
 
475
 
 
476
        slider.render( testbed );
 
477
 
 
478
        Y.Assert.areEqual( Y.config.base + 'slider-base/assets/skins/foo/thumb-x.png', slider.get('thumbUrl') );
 
479
 
 
480
        slider.destroy();
 
481
    },
 
482
 
 
483
    "test clickableRail": function () {
 
484
        
 
485
    },
 
486
 
 
487
    "test min": function () {
 
488
    },
 
489
 
 
490
    "test max": function () {
 
491
    },
 
492
 
 
493
    "test value": function () {
 
494
    }
 
495
}));
 
496
 
 
497
 
 
498
suite.add( new Y.Test.Case({
 
499
    name: "Runtime expectations",
 
500
 
 
501
    setUp: function () {
 
502
    },
 
503
 
 
504
    tearDown: function () {
 
505
    },
 
506
 
 
507
    "test ": function () {
 
508
    }
 
509
}));
 
510
 
 
511
/*
 
512
suite.add( new Y.Test.Case({
 
513
    name: "Bugs",
 
514
 
 
515
    setUp: function () {
 
516
    },
 
517
 
 
518
    tearDown: function () {
 
519
    },
 
520
 
 
521
    "test ": function () {
 
522
    }
 
523
}));
 
524
*/
 
525
 
 
526
Y.Test.Runner.add( suite );