| 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 | }); |