forked from node-fetch/node-fetch
/
index.test-d.ts
105 lines (86 loc) · 3.16 KB
/
index.test-d.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
import {expectType, expectAssignable} from 'tsd';
import AbortController from 'abort-controller';
import Blob from 'fetch-blob';
import fetch, {Request, Response, Headers, Body, FetchError, AbortError} from '.';
import * as _fetch from '.';
async function run() {
const getResponse = await fetch('https://bigfile.com/test.zip');
expectType<boolean>(getResponse.ok);
expectType<number>(getResponse.size);
expectType<number>(getResponse.status);
expectType<string>(getResponse.statusText);
expectType<() => Response>(getResponse.clone);
// Test async iterator over body
expectType<NodeJS.ReadableStream | null>(getResponse.body);
if (getResponse.body) {
for await (const data of getResponse.body) {
expectType<Buffer | string>(data);
}
}
// Test Buffer
expectType<Buffer>(await getResponse.buffer());
// Test arrayBuffer
expectType<ArrayBuffer>(await getResponse.arrayBuffer());
// Test JSON, returns unknown
expectType<unknown>(await getResponse.json());
// Headers iterable
expectType<Headers>(getResponse.headers);
// Post
try {
const request = new Request('http://byjka.com/buka');
expectType<string>(request.url);
expectType<Headers>(request.headers);
const headers = new Headers({byaka: 'buke'});
expectType<(a: string, b: string) => void>(headers.append);
expectType<(a: string) => string | null>(headers.get);
expectType<(name: string, value: string) => void>(headers.set);
expectType<(name: string) => void>(headers.delete);
expectType<() => IterableIterator<string>>(headers.keys);
expectType<() => IterableIterator<[string, string]>>(headers.entries);
expectType<() => IterableIterator<[string, string]>>(headers[Symbol.iterator]);
const postResponse = await fetch(request, {method: 'POST', headers});
expectType<Blob>(await postResponse.blob());
} catch (error: unknown) {
if (error instanceof FetchError) {
throw new TypeError(error.errno as string | undefined);
}
if (error instanceof AbortError) {
throw error;
}
}
// export *
const wildResponse = await _fetch.default('https://google.com');
expectType<boolean>(wildResponse.ok);
expectType<number>(wildResponse.size);
expectType<number>(wildResponse.status);
expectType<string>(wildResponse.statusText);
expectType<() => Response>(wildResponse.clone);
// Others
const response = new Response();
expectType<string>(response.url);
expectAssignable<Body>(response);
const abortController = new AbortController();
const request = new Request('url', {signal: abortController.signal});
expectAssignable<Body>(request);
/* eslint-disable no-new */
new Request('url', {agent: false});
new Headers({Header: 'value'});
// new Headers(['header', 'value']); // should not work
new Headers([['header', 'value']]);
new Headers(new Headers());
new Headers([
new Set(['a', '1']),
['b', '2'],
new Map([['a', null], ['3', null]]).keys()
]);
/* eslint-enable no-new */
expectType<Response>(Response.redirect('https://google.com'));
expectType<Response>(Response.redirect('https://google.com', 301));
expectType<Response>(Response.json({foo: 'bar'}));
expectType<Response>(Response.json({foo: 'bar'}, {
status: 301
}));
}
run().finally(() => {
console.log('✅');
});