starting with abort controller

Author: leftieFriele

lib/http-client.js

@@ -1,4 +1,4 @@
-import { Agent, setGlobalDispatcher, request, MockAgent } from 'undici';
+import { Agent, request } from 'undici';
 import createError from 'http-errors';
 import Opossum from 'opossum';
 import abslog from 'abslog';
@@ -31,6 +31,7 @@ export default class HttpClient extends EventEmitter {
      */
     constructor({
         abortController = undefined,
+        autoRenewAbortController = false,
         keepAliveMaxTimeout = undefined,
         keepAliveTimeout = undefined,
         connections = 50,
@@ -55,6 +56,7 @@ export default class HttpClient extends EventEmitter {
             ...(this.#abortController && {
                 abortController: this.#abortController,
             }),
+            ...(autoRenewAbortController && { autoRenewAbortController }),
             errorThresholdPercentage: threshold, // When X% of requests fail, trip the circuit
             resetTimeout: reset, // After X milliseconds, try again.
             timeout, // If our function takes longer than X milliseconds, trigger a failure
@@ -127,10 +129,4 @@ export default class HttpClient extends EventEmitter {
             await this.#agent.close();
         }
     }
-
-    // static mock(origin) {
-    //     const agent = new MockAgent();
-    //     setGlobalDispatcher(agent);
-    //     return agent.get(origin);
-    // }
 }

tests/http-client.test.js

@@ -9,8 +9,6 @@ let httpServer,
     host = 'localhost',
     port = 3003;
 
-const url = `http://${host}:${port}`;
-
 function beforeEach() {
     httpServer = http.createServer(async (request, response) => {
         response.writeHead(200);
@@ -19,15 +17,14 @@ function beforeEach() {
     httpServer.listen(port, host);
 }
 
-function closeServer() {
+function closeServer(s) {
     return new Promise((resolve) => {
-        httpServer.close(resolve);
-        console.log('Closed');
+        s.close(resolve);
     });
 }
-async function afterEach(client) {
+async function afterEach(client, server = httpServer) {
     await client.close();
-    await closeServer();
+    await closeServer(server);
 }
 
 async function queryUrl({
@@ -46,47 +43,80 @@ async function queryUrl({
     }
 }
 await test('http-client - basics', async (t) => {
+    const url = `http://${host}:2001`;
+    const server = http.createServer(async (request, response) => {
+        response.writeHead(200);
+        response.end();
+    });
+    server.listen(2001, host);
     await t.test('returns 200 response when given valid input', async () => {
-        beforeEach();
         const client = new HttpClient();
         const response = await client.request({
             path: '/',
             origin: url,
             method: 'GET',
         });
         assert.strictEqual(response.statusCode, 200);
-        await afterEach(client);
+        await client.close();
     });
 
-    // await t.test('does not cause havoc with built in fetch', async () => {
-    //     beforeEach();
-    //     const client = new HttpClient();
-    //     await fetch(url);
-    //     const response = await client.request({
-    //         path: '/',
-    //         origin: url,
-    //         method: 'GET',
-    //     });
-    //     assert.strictEqual(response.statusCode, 200);
-    //     await client.close();
-    //     await fetch(url);
-    //     await afterEach(client);
-    // });
-    await t.test('can pass in an abort controller', async () => {
-        beforeEach();
-        const abortController = new AbortController();
-
+    await t.test('does not cause havoc with built in fetch', async () => {
         const client = new HttpClient();
+        await fetch(url);
         const response = await client.request({
             path: '/',
             origin: url,
             method: 'GET',
         });
-        await afterEach(client);
+        assert.strictEqual(response.statusCode, 200);
+        await client.close();
+        await fetch(url);
+        await client.close();
     });
+    await closeServer(server);
+});
+
+await test('http-client - abort controller', async (t) => {
+    // Slow responding server to enable us to abort a request
+    const slowServer = http.createServer(async (request, response) => {
+        await wait(200);
+        response.writeHead(200);
+        response.end();
+    });
+    slowServer.listen(2010, host);
+    await t.test('cancel a request', async () => {
+        const abortController = new AbortController();
+        let aborted = false;
+        setTimeout(() => {
+            abortController.abort();
+            aborted = true;
+        }, 100);
+        const client = new HttpClient({ timeout: 2000 });
+        await client.request({
+            path: '/',
+            origin: 'http://localhost:2010',
+            method: 'GET',
+        });
+        assert.ok(aborted);
+        await client.close();
+    });
+
+    // await t.test('auto renew an abort controller', async () => {
+    //     const abortController = new AbortController();
+    //     const client = new HttpClient({ timeout: 2000 });
+    //     await client.request({
+    //         autoRenewAbortController: true,
+    //         path: '/',
+    //         origin: 'http://localhost:2010',
+    //         method: 'GET',
+    //     });
+    //     await client.close();
+    // });
+    slowServer.close();
 });
 
 await test('http-client - circuit breaker behaviour', async (t) => {
+    const url = `http://${host}:${port}`;
     await t.test('opens on failure threshold', async () => {
         beforeEach();
         const invalidUrl = `http://${host}:3013`;

tests/utilities.js

@@ -10,3 +10,11 @@ export async function wait(waitTime = 1000) {
         }, waitTime);
     });
 }
+export async function slowResponder(func, timeout = 1000) {
+    return new Promise((resolve) => {
+        setTimeout(async () => {
+            await func();
+            resolve();
+        }, timeout);
+    });
+}