Specs/Fx/Fx.js

   1 /*
   2 ---
   3 name: Fx
   4 requires: ~
   5 provides: ~
   6 ...
   7 */
   8
   9 describe('Fx', function(){
  10
  11         beforeEach(function(){
  12                 this.clock = sinon.useFakeTimers();
  13         });
  14
  15         afterEach(function(){
  16                 this.clock.reset();
  17                 this.clock.restore();
  18         });
  19
  20         Object.each(Fx.Transitions, function(value, transition){
  21                 if (transition == 'extend') return;
  22
  23                 it('should start a Fx and call the onComplete event with ' + transition + ' as timing function', function(){
  24                         var onComplete = sinon.spy(),
  25                                 onStart = sinon.spy();
  26
  27                         var fx = new Fx({
  28                                 duration: 500,
  29                                 transition: Fx.Transitions[transition],
  30                                 onComplete: onComplete,
  31                                 onStart: onStart
  32                         });
  33
  34                         expect(onStart.called).to.equal(false);
  35
  36                         fx.start(10, 20);
  37
  38                         this.clock.tick(100);
  39                         expect(onStart.called).to.equal(true);
  40                         expect(onComplete.called).to.equal(false);
  41
  42                         this.clock.tick(1000);
  43                         expect(onComplete.called).to.equal(true);
  44                 });
  45         });
  46
  47         it('should cancel a Fx', function(){
  48                 var onCancel = sinon.spy();
  49
  50                 var fx = new Fx({
  51                         duration: 500,
  52                         transition: 'sine:in:out',
  53                         onCancel: onCancel
  54                 });
  55
  56                 fx.start();
  57                 expect(onCancel.called).to.equal(false);
  58
  59                 fx.cancel();
  60                 expect(onCancel.called).to.equal(true);
  61         });
  62
  63         it('should set the computed value', function(){
  64                 var FxLog = new Class({
  65                         Extends: Fx,
  66                         set: function(current){
  67                                 this.foo = current;
  68                         }
  69                 });
  70
  71                 var fx = new FxLog({
  72                         duration: 1000
  73                 }).start(0, 10);
  74
  75                 this.clock.tick(2000);
  76                 expect(fx.foo).to.equal(10);
  77         });
  78
  79         it('should pause and resume', function(){
  80                 var FxLog = new Class({
  81                         Extends: Fx,
  82                         set: function(current){
  83                                 this.foo = current;
  84                         }
  85                 });
  86
  87                 var fx = new FxLog({
  88                         duration: 2000
  89                 }).start(0, 1);
  90
  91                 this.clock.tick(1000);
  92
  93                 var value;
  94
  95                 fx.pause();
  96                 value = fx.foo;
  97                 expect(fx.foo).to.be.greaterThan(0);
  98                 expect(fx.foo).to.be.lessThan(1);
  99
 100                 this.clock.tick(1000);
 101
 102                 expect(fx.foo).to.equal(value);
 103                 fx.resume();
 104
 105                 this.clock.tick(2000);
 106                 expect(fx.foo).to.equal(1);
 107         });
 108
 109         it('should chain the Fx', function(){
 110                 var counter = 0;
 111                 var fx = new Fx({
 112                         duration: 500,
 113                         onComplete: function(){
 114                                 counter++;
 115                         },
 116                         link: 'chain'
 117                 });
 118
 119                 fx.start().start();
 120
 121                 this.clock.tick(1000);
 122                 this.clock.tick(1000);
 123
 124                 expect(counter).to.equal(2);
 125         });
 126
 127         it('should cancel the Fx after a new Fx:start with the link = cancel option', function(){
 128                 var onCancel = sinon.spy();
 129
 130                 var fx = new Fx({
 131                         duration: 500,
 132                         onCancel: onCancel,
 133                         link: 'cancel'
 134                 });
 135
 136                 fx.start().start();
 137
 138                 this.clock.tick(1000);
 139                 expect(onCancel.called).to.equal(true);
 140         });
 141
 142         it('should return the paused state', function(){
 143                 var fx = new Fx({
 144                         duration: 500
 145                 }).start();
 146
 147                 expect(fx.isPaused()).to.equal(false);
 148
 149                 this.clock.tick(300);
 150                 fx.pause();
 151
 152                 expect(fx.isPaused()).to.equal(true);
 153
 154                 fx.resume();
 155                 this.clock.tick(600);
 156                 expect(fx.isPaused()).to.equal(false);
 157         });
 158
 159 });
 160
 161 describe('Fx (thenable)', function(){
 162
 163         beforeEach(function(){
 164                 this.fx = new Fx({
 165                         duration: 1,
 166                         transition: 'sine:in:out'
 167                 });
 168
 169                 var self = this;
 170                 this.onFulfilled = sinon.spy(function(){ self.expectations.apply(self, arguments); });
 171                 this.onRejected = sinon.spy(function(){ self.expectations.apply(self, arguments); });
 172
 173                 this.fx.then(this.onFulfilled, this.onRejected);
 174         });
 175
 176         it('should fulfill when completed', function(done){
 177                 this.fx.start(10, 20);
 178
 179                 expect(this.onRejected.called).to.equal(false);
 180                 expect(this.onFulfilled.called).to.equal(false);
 181
 182                 this.expectations = function(){
 183                         var error;
 184                         try {
 185                                 expect(this.onRejected.called).to.equal(false);
 186                                 expect(this.onFulfilled.called).to.equal(true);
 187                                 expect(this.onFulfilled.args[0][0]).to.equal(null);
 188                         } catch (thrown){
 189                                 error = thrown;
 190                         }
 191                         done(error);
 192                 }
 193         });
 194
 195         it('should reject when cancelled', function(done){
 196                 this.fx.start();
 197
 198                 expect(this.onFulfilled.called).to.equal(false);
 199                 expect(this.onRejected.called).to.equal(false);
 200
 201                 this.fx.cancel();
 202
 203                 this.expectations = function(){
 204                         var error;
 205                         try {
 206                                 expect(this.onFulfilled.called).to.equal(false);
 207                                 expect(this.onRejected.called).to.equal(true);
 208                                 expect(this.onRejected.args[0][0]).to.equal(this.fx);
 209                         } catch (thrown){
 210                                 error = thrown;
 211                         }
 212                         done(error);
 213                 }
 214         });
 215
 216 });