urllib/test/options.retry.test.ts at a75706ea4fe8f1e2a5208763d62c04660a06abe7 · node-modules/urllib · GitHub

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
import { strict as assert } from 'node:assert';
import { createWriteStream, createReadStream } from 'node:fs';
import { describe, it, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
import urllib, { getGlobalDispatcher, MockAgent, setGlobalDispatcher } from '../src';
import { startServer } from './fixtures/server';
import { readableToString, createTempfile } from './utils';

describe('options.retry.test.ts', () => {
  let close: any;
  let _url: string;
  let tmpfile: string;
  let cleanup: any;

  let mockAgent: MockAgent;
  const globalAgent = getGlobalDispatcher();

  beforeAll(async () => {
    const { closeServer, url } = await startServer();
    close = closeServer;
    _url = url;
  });
  afterAll(async () => {
    await close();
  });

  beforeEach(async () => {
    const item = await createTempfile();
    tmpfile = item.tmpfile;
    cleanup = item.cleanup;
    mockAgent = new MockAgent();
    setGlobalDispatcher(mockAgent);
  });
  afterEach(async () => {
    await cleanup();
    setGlobalDispatcher(globalAgent);
    await mockAgent.close();
  });

  it('should not retry on 400', async () => {
    const response = await urllib.request(`${_url}mock-status?status=400`, {
      dataType: 'text',
      retry: 2,
    });
    assert.equal(response.status, 400);
    assert.equal(response.data, 'Mock status 400');
    const requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], undefined);
  });

  it('should not retry on streaming', async () => {
    const response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 2,
      streaming: true,
    });
    assert.equal(response.status, 500);
    const requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], undefined);
    const text = await readableToString(response.res as any);
    assert.equal(text, 'Mock status 500');
  });

  it('should not retry on writeStream', async () => {
    const writeStream = createWriteStream(tmpfile);
    const response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 2,
      writeStream,
    });
    assert.equal(response.status, 500);
    const requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], undefined);
    const text = await readableToString(createReadStream(tmpfile));
    assert.equal(text, 'Mock status 500');
  });

  it('should retry fail on default server status 500', async () => {
    let response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 2,
    });
    assert.equal(response.status, 500);
    assert.equal(response.data, 'Mock status 500');
    let requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], '2/2');
    assert(parseInt(response.headers['x-requests-persocket'] as string) >= 2);
    // console.log(response.headers);

    response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 1,
    });
    assert.equal(response.status, 500);
    assert.equal(response.data, 'Mock status 500');
    // console.log(response.headers);
    requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], '1/1');
    assert(parseInt(response.headers['x-requests-persocket'] as string) >= 2);

    response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 5,
    });
    assert.equal(response.status, 500);
    assert.equal(response.data, 'Mock status 500');
    // console.log(response.headers);
    requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], '5/5');
    assert(parseInt(response.headers['x-requests-persocket'] as string) >= 2);
  });

  it('should custom isRetry', async () => {
    const response = await urllib.request(`${_url}mock-status?status=400`, {
      dataType: 'text',
      retry: 2,
      isRetry(response) {
        return response.status === 400;
      },
    });
    assert.equal(response.status, 400);
    assert.equal(response.data, 'Mock status 400');
    const requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], '2/2');
  });

  it('should retry with delay', async () => {
    const startTime = Date.now();
    const response = await urllib.request(`${_url}mock-status?status=500`, {
      dataType: 'text',
      retry: 3,
      retryDelay: 110,
    });
    assert.equal(response.status, 500);
    assert.equal(response.data, 'Mock status 500');
    const requestHeaders = JSON.parse(response.headers['x-request-headers'] as string);
    assert.equal(requestHeaders['x-urllib-retry'], '3/3');
    const use = Date.now() - startTime;
    assert(use >= 330);
  });
});