Specs/Class/Class.Extras.js

   1 /*
   2 ---
   3 name: Class.Extras
   4 requires: ~
   5 provides: ~
   6 ...
   7 */
   8
   9 var Local = Local || {};
  10
  11 describe('Chain', function(){
  12
  13         Local.Chain = new Class({
  14
  15                 Implements: Chain
  16
  17         });
  18
  19         it('callChain should not fail when nothing was added to the chain', function(){
  20                 var chain = new Local.Chain();
  21                 chain.callChain();
  22         });
  23
  24         it('should pass arguments to the function and return values', function(){
  25                 var chain = new Local.Chain();
  26                 var arr = [];
  27                 chain.chain(function(a, b){
  28                         var str = "0" + b + a;
  29                         arr.push(str);
  30                         return str;
  31                 });
  32                 chain.chain(function(a, b){
  33                         var str = "1" + b + a;
  34                         arr.push(str);
  35                         return str;
  36                 });
  37                 var ret;
  38                 expect(arr).toEqual([]);
  39                 ret = chain.callChain("a", "A");
  40                 expect(ret).toEqual("0Aa");
  41                 expect(arr).toEqual(["0Aa"]);
  42
  43                 ret = chain.callChain("b", "B");
  44                 expect(ret).toEqual("1Bb");
  45                 expect(arr).toEqual(["0Aa", "1Bb"]);
  46
  47                 ret = chain.callChain();
  48                 expect(ret).toEqual(false);
  49                 expect(arr).toEqual(["0Aa", "1Bb"]);
  50         });
  51
  52         it('should chain any number of functions', function(){
  53                 var chain = new Local.Chain();
  54                 var arr = [];
  55
  56                 chain.chain(function(){
  57                         arr.push(0);
  58                 }, function(){
  59                         arr.push(1);
  60                 });
  61
  62                 expect(arr).toEqual([]);
  63                 chain.callChain();
  64                 expect(arr).toEqual([0]);
  65                 chain.chain(function(){
  66                         arr.push(2);
  67                 });
  68                 chain.callChain();
  69                 expect(arr).toEqual([0, 1]);
  70                 chain.callChain();
  71                 expect(arr).toEqual([0, 1, 2]);
  72                 chain.callChain();
  73                 expect(arr).toEqual([0, 1, 2]);
  74         });
  75
  76         it('should allow an array of functions', function(){
  77                 var chain = new Local.Chain();
  78                 var arr = [];
  79
  80                 chain.chain([function(){
  81                         arr.push(0);
  82                 }, function(){
  83                         arr.push(1);
  84                 }, function(){
  85                         arr.push(2);
  86                 }]);
  87
  88                 expect(arr).toEqual([]);
  89                 chain.callChain();
  90                 expect(arr).toEqual([0]);
  91                 chain.callChain();
  92                 expect(arr).toEqual([0, 1]);
  93                 chain.callChain();
  94                 expect(arr).toEqual([0, 1, 2]);
  95                 chain.callChain();
  96                 expect(arr).toEqual([0, 1, 2]);
  97         });
  98
  99         it('each instance should have its own chain', function(){
 100                 var foo = new Local.Chain();
 101                 var bar = new Local.Chain();
 102                 foo.val = "F";
 103                 bar.val = "B";
 104                 foo.chain(function(){
 105                         this.val += 'OO';
 106                 });
 107                 bar.chain(function(){
 108                         this.val += 'AR';
 109                 });
 110                 expect(foo.val).toEqual('F');
 111                 expect(bar.val).toEqual('B');
 112                 foo.callChain();
 113                 bar.callChain();
 114                 expect(foo.val).toEqual('FOO');
 115                 expect(bar.val).toEqual('BAR');
 116         });
 117
 118         it('should be able to clear the chain', function(){
 119                 var called;
 120                 var fn = function(){
 121                         called = true;
 122                 };
 123
 124                 var chain = new Local.Chain();
 125                 chain.chain(fn, fn, fn, fn);
 126
 127                 chain.callChain();
 128                 expect(called).toBeTruthy();
 129                 called = false;
 130
 131                 chain.clearChain();
 132
 133                 chain.callChain();
 134                 expect(called).toBeFalsy();
 135                 called = false;
 136         });
 137
 138         it('should be able to clear the chain from within', function(){
 139                 var foo = new Local.Chain();
 140
 141                 var test = 0;
 142                 foo.chain(function(){
 143                         test++;
 144                         foo.clearChain();
 145                 }).chain(function(){
 146                         test++;
 147                 }).callChain();
 148
 149                 expect(test).toEqual(1);
 150         });
 151
 152 });
 153
 154 var fire = 'fireEvent', create = function(){
 155         return new Events();
 156 };
 157
 158 describe('Events API: Mixin', function(){
 159
 160         beforeEach(function(){
 161                 Local.called = 0;
 162                 Local.fn = function(){
 163                         return Local.called++;
 164                 };
 165         });
 166
 167         it('should add an Event to the Class', function(){
 168                 var object = create();
 169
 170                 object.addEvent('event', Local.fn)[fire]('event');
 171
 172                 expect(Local.called).toEqual(1);
 173         });
 174
 175         it('should add multiple Events to the Class', function(){
 176                 create().addEvents({
 177                         event1: Local.fn,
 178                         event2: Local.fn
 179                 })[fire]('event1')[fire]('event2');
 180
 181                 expect(Local.called).toEqual(2);
 182         });
 183
 184         it('should remove a specific method for an event', function(){
 185                 var object = create();
 186                 var x = 0, fn = function(){ x++; };
 187
 188                 object.addEvent('event', Local.fn).addEvent('event', fn).removeEvent('event', Local.fn)[fire]('event');
 189
 190                 expect(x).toEqual(1);
 191                 expect(Local.called).toEqual(0);
 192         });
 193
 194         it('should remove an event and its methods', function(){
 195                 var object = create();
 196                 var x = 0, fn = function(){ x++; };
 197
 198                 object.addEvent('event', Local.fn).addEvent('event', fn).removeEvents('event')[fire]('event');
 199
 200                 expect(x).toEqual(0);
 201                 expect(Local.called).toEqual(0);
 202         });
 203
 204         it('should remove all events', function(){
 205                 var object = create();
 206                 var x = 0, fn = function(){ x++; };
 207
 208                 object.addEvent('event1', Local.fn).addEvent('event2', fn).removeEvents();
 209                 object[fire]('event1')[fire]('event2');
 210
 211                 // Should not fail
 212                 object.removeEvents()[fire]('event1')[fire]('event2');
 213
 214                 expect(x).toEqual(0);
 215                 expect(Local.called).toEqual(0);
 216         });
 217
 218         it('should remove events with an object', function(){
 219                 var object = create();
 220                 var events = {
 221                         event1: Local.fn,
 222                         event2: Local.fn
 223                 };
 224
 225                 object.addEvent('event1', function(){ Local.fn(); }).addEvents(events)[fire]('event1');
 226                 expect(Local.called).toEqual(2);
 227
 228                 object.removeEvents(events);
 229                 object[fire]('event1');
 230                 expect(Local.called).toEqual(3);
 231
 232                 object[fire]('event2');
 233                 expect(Local.called).toEqual(3);
 234         });
 235
 236         it('should remove an event immediately', function(){
 237                 var object = create();
 238
 239                 var methods = [];
 240
 241                 var three = function(){
 242                         methods.push(3);
 243                 };
 244
 245                 object.addEvent('event', function(){
 246                         methods.push(1);
 247                         this.removeEvent('event', three);
 248                 }).addEvent('event', function(){
 249                         methods.push(2);
 250                 }).addEvent('event', three);
 251
 252                 object[fire]('event');
 253                 expect(methods).toEqual([1, 2]);
 254
 255                 object[fire]('event');
 256                 expect(methods).toEqual([1, 2, 1, 2]);
 257         });
 258
 259         it('should be able to remove itself', function(){
 260                 var object = create();
 261
 262                 var methods = [];
 263
 264                 var one = function(){
 265                         object.removeEvent('event', one);
 266                         methods.push(1);
 267                 };
 268                 var two = function(){
 269                         object.removeEvent('event', two);
 270                         methods.push(2);
 271                 };
 272                 var three = function(){
 273                         methods.push(3);
 274                 };
 275
 276                 object.addEvent('event', one).addEvent('event', two).addEvent('event', three);
 277
 278                 object[fire]('event');
 279                 expect(methods).toEqual([1, 2, 3]);
 280
 281                 object[fire]('event');
 282                 expect(methods).toEqual([1, 2, 3, 3]);
 283         });
 284
 285 });
 286
 287 describe('Options Class', function(){
 288
 289         Local.OptionsTest = new Class({
 290                 Implements: [Options, Events],
 291
 292                 options: {
 293                         a: 1,
 294                         b: 2
 295                 },
 296
 297                 initialize: function(options){
 298                         this.setOptions(options);
 299                 }
 300         });
 301
 302         it('should set options', function(){
 303                 var myTest = new Local.OptionsTest({a: 1, b: 3});
 304                 expect(myTest.options).not.toEqual(undefined);
 305         });
 306
 307         it('should override default options', function(){
 308                 var myTest = new Local.OptionsTest({a: 3, b: 4});
 309                 expect(myTest.options.a).toEqual(3);
 310                 expect(myTest.options.b).toEqual(4);
 311         });
 312
 313 });
 314
 315 describe('Options Class with Events', function(){
 316
 317         beforeEach(function(){
 318                 Local.OptionsTest = new Class({
 319                         Implements: [Options, Events],
 320
 321                         options: {
 322                                 onEvent1: function(){
 323                                         return true;
 324                                 },
 325                                 onEvent2: function(){
 326                                         return false;
 327                                 }
 328                         },
 329
 330                         initialize: function(options){
 331                                 this.setOptions(options);
 332                         }
 333                 });
 334         });
 335
 336         it('should add events in the options object if class has implemented the Events class', function(){
 337                 var myTest = new Local.OptionsTest({
 338                         onEvent2: function(){
 339                                 return true;
 340                         },
 341
 342                         onEvent3: function(){
 343                                 return true;
 344                         }
 345                 });
 346
 347                 expect(myTest.$events.event1.length).toEqual(1);
 348                 expect(myTest.$events.event2.length).toEqual(1);
 349                 expect(myTest.$events.event3.length).toEqual(1);
 350         });
 351
 352 });
 353
 354 describe('setOptions', function(){
 355
 356         it('should allow to pass the document', function(){
 357
 358                 var A = new Class({
 359
 360                         Implements: Options,
 361
 362                         initialize: function(options){
 363                                 this.setOptions(options);
 364                         }
 365
 366                 });
 367
 368                 expect(new A({document: document}).options.document == document).toBeTruthy();
 369         });
 370
 371 });