www.aleph1.co.uk Git - yaffs-website/blob - node_modules/request-progress/test/test.js

   1 'use strict';
   2
   3 var expect = require('expect.js');
   4 var EventEmitter = require('events').EventEmitter;
   5 var progress = require('../');
   6
   7 function normalizeStates(states) {
   8     states.forEach(function (state) {
   9         state.time.elapsed = Math.round(state.time.elapsed),
  10         state.time.remaining = state.time.remaining != null ? Math.round(state.time.remaining) : null;
  11         state.speed = state.speed != null ? Math.round(state.speed) : null;
  12     });
  13 }
  14
  15 describe('request-progress', function () {
  16     var request;
  17     var states;
  18
  19     beforeEach(function () {
  20         states = [];
  21         request = new EventEmitter();
  22
  23         request.on('progress', function (state) {
  24             states.push(JSON.parse(JSON.stringify(state)));
  25         });
  26     });
  27
  28     it('should emit the progress event with the correct state information', function (done) {
  29         progress(request, { throttle: 0 })
  30         .on('end', function () {
  31             normalizeStates(states);
  32
  33             expect(states).to.eql([{
  34                 percentage: 0.5,
  35                 speed: null,
  36                 size: { total: 10, transferred: 5, },
  37                 time: { elapsed: 0, remaining: null }
  38             }, {
  39                 percentage: 0.8,
  40                 speed: 7,
  41                 size: { total: 10, transferred: 8 },
  42                 time: { elapsed: 1, remaining: 0 }
  43             }, {
  44                 percentage: 1,
  45                 speed: 8,
  46                 size: { total: 10, transferred: 10 },
  47                 time: { elapsed: 1, remaining: 0 }
  48             }]);
  49
  50             done();
  51         });
  52
  53         request.emit('request');
  54         request.emit('response', { headers: { 'content-length': 10 } });
  55
  56         setTimeout(function () {
  57             request.emit('data', new Buffer('aaaaa'));
  58         }, 25);
  59
  60         setTimeout(function () {
  61             request.emit('data', new Buffer('bbb'));
  62         }, 1150);
  63
  64         setTimeout(function () {
  65             request.emit('data', new Buffer('cc'));
  66             request.emit('end');
  67         }, 1250);
  68     });
  69
  70     it('should provide request.progressState (and request.progressContext)', function (done) {
  71         progress(request, { throttle: 0 })
  72         .on('end', function () {
  73             expect(request.progressState).to.be(null);
  74             expect(request.progressContext).to.be(null);
  75             done();
  76         });
  77
  78         expect(request.progressContext).to.be.an('object');
  79         expect(request.progressState).to.be(undefined);
  80
  81         request.emit('request');
  82         request.emit('response', { headers: { 'content-length': 2 } });
  83
  84         expect(request.progressContext).to.be.an('object');
  85         expect(request.progressState).to.be.an('object');
  86
  87         setTimeout(function () {
  88             request.emit('data', new Buffer('a'));
  89             expect(request.progressContext).to.be.an('object');
  90             expect(request.progressState).to.be.an('object');
  91             expect(request.progressState.percentage).to.be(0.5);
  92         }, 25);
  93
  94         setTimeout(function () {
  95             request.emit('data', new Buffer('b'));
  96             expect(request.progressContext).to.be.an('object');
  97             expect(request.progressState).to.be.an('object');
  98             expect(request.progressState.percentage).to.be(1);
  99             request.emit('end');
 100         }, 100);
 101     });
 102
 103     it('should have a option.delay default of 0', function () {
 104         progress(request);
 105         expect(request.progressContext.options.delay).to.be(0);
 106     });
 107
 108     it('should respect the passed option.delay', function (done) {
 109         progress(request, { throttle: 0, delay: 250 })
 110         .on('end', function () {
 111             expect(states).to.have.length(2);
 112             expect(states[0].percentage).to.be(0.6);
 113             expect(states[1].percentage).to.be(1);
 114
 115             done();
 116         });
 117
 118         request.emit('request');
 119         request.emit('response', { headers: { 'content-length': 10 } });
 120
 121         setTimeout(function () {
 122             request.emit('data', new Buffer('aa'));
 123         }, 25);
 124
 125         setTimeout(function () {
 126             request.emit('data', new Buffer('bb'));
 127         }, 200);
 128
 129         setTimeout(function () {
 130             request.emit('data', new Buffer('cc'));
 131         }, 300);
 132
 133         setTimeout(function () {
 134             request.emit('data', new Buffer('dddd'));
 135             request.emit('end');
 136         }, 400);
 137     });
 138
 139     it('should have a option.throttle default of 1000', function () {
 140         progress(request);
 141         expect(request.progressContext.options.throttle).to.be(1000);
 142     });
 143
 144     it('should respect the passed option.throttle', function (done) {
 145         progress(request, { throttle: 300, delay: 0 })
 146         .on('end', function () {
 147             expect(states).to.have.length(3);
 148             expect(states[0].percentage).to.be(0.2);
 149             expect(states[1].percentage).to.be(0.6);
 150             expect(states[2].percentage).to.be(0.9);
 151
 152             done();
 153         });
 154
 155         request.emit('request');
 156         request.emit('response', { headers: { 'content-length': 10 } });
 157
 158         setTimeout(function () {
 159             request.emit('data', new Buffer('aa'));
 160         }, 25);
 161
 162         setTimeout(function () {
 163             request.emit('data', new Buffer('bb'));
 164         }, 100);
 165
 166         setTimeout(function () {
 167             request.emit('data', new Buffer('cc'));
 168         }, 300);
 169
 170         setTimeout(function () {
 171             request.emit('data', new Buffer('dd'));
 172         }, 400);
 173
 174         setTimeout(function () {
 175             request.emit('data', new Buffer('e'));
 176         }, 500);
 177
 178         setTimeout(function () {
 179             request.emit('data', new Buffer('bf'));
 180             request.emit('end');
 181         }, 700);
 182     });
 183
 184     it('should have a option.lengthHeader default of "content-length"', function () {
 185         progress(request);
 186         expect(request.progressContext.options.lengthHeader).to.be('content-length');
 187     });
 188
 189     it('should use option.lengthHeader', function (done) {
 190         progress(request, {
 191             throttle: 0,
 192             lengthHeader: 'x-transfer-length'
 193         })
 194         .on('end', function () {
 195             expect(states).to.have.length(2);
 196             expect(states[0].percentage).to.be(0.5);
 197             expect(states[0].size.total).to.be(10);
 198             expect(states[1].percentage).to.be(1);
 199             expect(states[1].size.total).to.be(10);
 200
 201             done();
 202         });
 203
 204         request.emit('request');
 205         request.emit('response', {
 206             headers: { 'x-transfer-length': 10, 'content-length': 5 }
 207         });
 208
 209         setTimeout(function () {
 210             request.emit('data', new Buffer('aaaaa'));
 211         }, 25);
 212
 213         setTimeout(function () {
 214             request.emit('data', new Buffer('bbbbb'));
 215             request.emit('end');
 216         }, 200);
 217     });
 218
 219     it('should fail if response is already set', function () {
 220         request.response = { headers: { 'content-length': 10 } };
 221
 222         expect(function () {
 223             progress(request);
 224         }).to.throwException(/too late/);
 225     });
 226
 227     it('should deal with unknown content length', function (done) {
 228         progress(request, { throttle: 0 })
 229         .on('end', function () {
 230             normalizeStates(states);
 231
 232             expect(states).to.eql([{
 233                 percentage: null,
 234                 speed: null,
 235                 size: { total: null, transferred: 5, },
 236                 time: { elapsed: 0, remaining: null }
 237             }, {
 238                 percentage: null,
 239                 speed: 10,
 240                 size: { total: null, transferred: 12, },
 241                 time: { elapsed: 1, remaining: null }
 242             }]);
 243
 244             done();
 245         });
 246
 247         request.emit('request');
 248         request.emit('response', { headers: {} });
 249
 250         setTimeout(function () {
 251             request.emit('data', new Buffer('aaaaa'));
 252         }, 25);
 253
 254         setTimeout(function () {
 255             request.emit('data', new Buffer('bbbbbbb'));
 256             request.emit('end');
 257         }, 1150);
 258     });
 259
 260     it('should deal with payloads higher than the content length', function (done) {
 261         progress(request, { throttle: 0 })
 262         .on('end', function () {
 263             normalizeStates(states);
 264
 265             expect(states).to.eql([{
 266                 percentage: 0.5,
 267                 speed: null,
 268                 size: { total: 10, transferred: 5, },
 269                 time: { elapsed: 0, remaining: null }
 270             }, {
 271                 percentage: 1,
 272                 speed: 10,
 273                 size: { total: 10, transferred: 12 },
 274                 time: { elapsed: 1, remaining: 0 }
 275             }]);
 276
 277             done();
 278         });
 279
 280         request.emit('request');
 281         request.emit('response', { headers: { 'content-length': 10 } });
 282
 283         setTimeout(function () {
 284             request.emit('data', new Buffer('aaaaa'));
 285         }, 25);
 286
 287         setTimeout(function () {
 288             request.emit('data', new Buffer('bbbbbbb'));
 289             request.emit('end');
 290         }, 1150);
 291     });
 292
 293     it('should not report after the request ends', function (done) {
 294         progress(request, { throttle: 100 });
 295
 296         request.emit('request');
 297         request.emit('response', { headers: { 'content-length': 10 } });
 298
 299         setTimeout(function () {
 300             request.emit('data', new Buffer('aa'));
 301         }, 25);
 302
 303         setTimeout(function () {
 304             request.emit('data', new Buffer('bbbbbbbb'));
 305             request.emit('end');
 306         }, 50);
 307
 308         setTimeout(function () {
 309             normalizeStates(states);
 310
 311             expect(states).to.have.length(1);
 312             expect(states[0].percentage).to.be(0.2);
 313
 314             done();
 315         }, 500);
 316     });
 317
 318     it('should not generate duplicate progress events if called twice', function (done) {
 319         progress(request, { throttle: 0 });
 320         progress(request, { throttle: 0 })
 321         .on('end', function () {
 322             expect(states).to.have.length(1);
 323             expect(states[0].percentage).to.be(1);
 324
 325             done();
 326         });
 327
 328         request.emit('request');
 329         request.emit('response', { headers: { 'content-length': 2 } });
 330
 331         setTimeout(function () {
 332             request.emit('data', new Buffer('aa'));
 333             request.emit('end');
 334         }, 25);
 335     });
 336
 337     it('should reset stuff on "request" event', function () {
 338         progress(request, { throttle: 0 });
 339
 340         expect(request.progressContext).to.be.an('object');
 341         expect(request.progressState).to.be(undefined);
 342
 343         request.emit('request');
 344         request.emit('response', { headers: { 'content-length': 2 } });
 345
 346         expect(request.progressContext).to.be.an('object');
 347         expect(request.progressState).to.be.an('object');
 348
 349         request.emit('request');
 350
 351         expect(request.progressContext).to.be.an('object');
 352         expect(request.progressState).to.be(null);
 353     });
 354 });