BlueGit

blue-star danique-bot

Files

danique-bot / node_modules / request-progress / test / test.js

test.js

Import template
timfa Tim · pushed by timfa · 4 years ago
c788ad20 History
test.js 10.7 KiB Download Raw
1'use strict';
2
3var expect = require('expect.js');
4var EventEmitter = require('events').EventEmitter;
5var progress = require('../');
6
7function 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
15describe('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});