/
cancel.ts
218 lines (169 loc) 路 5.65 KB
/
cancel.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
import {EventEmitter} from 'events';
import {Readable as ReadableStream} from 'stream';
import stream = require('stream');
import test from 'ava';
import pEvent = require('p-event');
import getStream = require('get-stream');
// @ts-ignore
import got, {CancelError} from '../source';
import withServer, {withServerAndLolex} from './helpers/with-server';
import slowDataStream from './helpers/slow-data-stream';
const prepareServer = (server, clock) => {
const emitter = new EventEmitter();
const promise = new Promise((resolve, reject) => {
server.all('/abort', async (request, response) => {
emitter.emit('connection');
request.once('aborted', resolve);
response.once('finish', reject.bind(null, new Error('Request finished instead of aborting.')));
await pEvent(request, 'end');
response.end();
});
server.get('/redirect', (_request, response) => {
response.writeHead(302, {
location: `${server.url}/abort`
});
response.end();
emitter.emit('sentRedirect');
clock.tick(3000);
resolve();
});
});
return {emitter, promise};
};
const downloadHandler = clock => (_request, response) => {
response.writeHead(200, {
'transfer-encoding': 'chunked'
});
response.flushHeaders();
stream.pipeline(
slowDataStream(clock),
response,
() => {
response.end();
}
);
};
test.serial('does not retry after cancelation', withServerAndLolex, async (t, server, got, clock) => {
const {emitter, promise} = prepareServer(server, clock);
const gotPromise = got('redirect', {
retry: {
retries: () => {
t.fail('Makes a new try after cancelation');
}
}
});
emitter.once('sentRedirect', () => {
gotPromise.cancel();
});
// @ts-ignore
await t.throwsAsync(gotPromise, CancelError);
// @ts-ignore
await t.notThrowsAsync(promise, 'Request finished instead of aborting.');
});
test.serial('cancels in-progress request', withServerAndLolex, async (t, server, got, clock) => {
const {emitter, promise} = prepareServer(server, clock);
const body = new ReadableStream({
read() {} // eslint-disable-line @typescript-eslint/no-empty-function
});
body.push('1');
const gotPromise = got.post('abort', {body});
// Wait for the connection to be established before canceling
emitter.once('connection', () => {
gotPromise.cancel();
body.push(null);
});
await t.throwsAsync(gotPromise, CancelError);
await t.notThrowsAsync(promise, 'Request finished instead of aborting.');
});
test.serial('cancels in-progress request with timeout', withServerAndLolex, async (t, server, got, clock) => {
const {emitter, promise} = prepareServer(server, clock);
const body = new ReadableStream({
read() {} // eslint-disable-line @typescript-eslint/no-empty-function
});
body.push('1');
const gotPromise = got.post('abort', {body, timeout: 10000});
// Wait for the connection to be established before canceling
emitter.once('connection', () => {
gotPromise.cancel();
body.push(null);
});
await t.throwsAsync(gotPromise, CancelError);
await t.notThrowsAsync(promise, 'Request finished instead of aborting.');
});
test.serial('cancel immediately', withServerAndLolex, async (t, server, got, clock) => {
const promise = new Promise((resolve, reject) => {
// We won't get an abort or even a connection
// We assume no request within 1000ms equals a (client side) aborted request
server.get('/abort', (_request, response) => {
response.once('finish', reject.bind(this, new Error('Request finished instead of aborting.')));
response.end();
});
clock.tick(1000);
resolve();
});
const gotPromise = got('abort');
gotPromise.cancel();
await t.throwsAsync(gotPromise);
await t.notThrowsAsync(promise, 'Request finished instead of aborting.');
});
test('recover from cancelation using cancelable promise attribute', async t => {
// Canceled before connection started
const p = got('http://example.com');
const recover = p.catch(error => {
if (p.isCanceled) {
return;
}
throw error;
});
p.cancel();
await t.notThrowsAsync(recover);
});
test('recover from cancellation using error instance', async t => {
// Canceled before connection started
const p = got('http://example.com');
const recover = p.catch(error => {
if (error instanceof got.CancelError) {
return;
}
throw error;
});
p.cancel();
await t.notThrowsAsync(recover);
});
test.serial('throws on incomplete (canceled) response - promise', withServerAndLolex, async (t, server, got, clock) => {
server.get('/', downloadHandler(clock));
await t.throwsAsync(got({
timeout: {request: 500},
retry: 0
}), got.TimeoutError);
});
test.serial('throws on incomplete (canceled) response - promise #2', withServerAndLolex, async (t, server, got, clock) => {
server.get('/', downloadHandler(clock));
const promise = got('').on('response', () => {
clock.tick(500);
promise.cancel();
});
await t.throwsAsync(promise, got.CancelError);
});
test.serial('throws on incomplete (canceled) response - stream', withServerAndLolex, async (t, server, got, clock) => {
server.get('/', downloadHandler(clock));
const errorString = 'Foobar';
const stream = got.stream('').on('response', () => {
clock.tick(500);
stream.destroy(new Error(errorString));
});
await t.throwsAsync(getStream(stream), errorString);
});
// Note: it will throw, but the response is loaded already.
test('throws when canceling cached request', withServer, async (t, server, got) => {
server.get('/', (_request, response) => {
response.setHeader('Cache-Control', 'public, max-age=60');
response.end(Date.now().toString());
});
const cache = new Map();
await got({cache});
const promise = got({cache}).on('response', () => {
promise.cancel();
});
await t.throwsAsync(promise, got.CancelError);
});