refactor spec

Author: lipsumar

test/ca.spec.ts

@@ -7,8 +7,6 @@ import { expect, fetch, ignoreNetworkError, nodeOnly } from "./test-utils";
 
 import { CA, generateCACertificate } from '../src/util/tls';
 
-const nodeMajorVersion = parseInt(process.versions.node.split('.')[0], 10);
-
 nodeOnly(() => {
     describe("Certificate generation", () => {
         const caKey = fs.readFile(path.join(__dirname, 'fixtures', 'test-ca.key'), 'utf8');
@@ -35,6 +33,21 @@ nodeOnly(() => {
             let constrainedCA: CA;
             let constrainedCaCert: string;
 
+            function localhostRequest({ hostname, port }: { hostname: string; port: number }) {
+                return https.request({
+                    hostname,
+                    port,
+                    ca: [constrainedCaCert],
+                    lookup: (_, options, callback) => {
+                        if (options.all) {
+                            callback(null, [{ address: "127.0.0.1", family: 4 }]);
+                        } else {
+                            callback(null, "127.0.0.1", 4);
+                        }
+                    },
+                });
+            }
+
             beforeEach(async () => {
                 const rootCa = await generateCACertificate({
                     nameConstraints: { permitted: ["example.com"] },
@@ -53,28 +66,18 @@ nodeOnly(() => {
                 });
                 await new Promise<void>((resolve) => server.listen(4430, resolve));
 
-                await new Promise<void>((resolve) => {
-                    const req = https.request(
-                        {
-                            hostname: "hello.example.com",
-                            port: 4430,
-                            ca: [constrainedCaCert],
-                            lookup: (hostname, options, callback) => {
-                                if (nodeMajorVersion <= 18) {
-                                    callback(null, "127.0.0.1", 4);
-                                } else {
-                                    callback(null, [{ address: "127.0.0.1", family: 4 }]);
-                                }
-                            },
-                        },
-                        (res) => {
-                            expect(res.statusCode).to.equal(200);
-                            res.on("data", (data) => {
-                                expect(data.toString()).to.equal("signed response!");
-                                resolve();
-                            });
-                        }
-                    );
+                const req = localhostRequest({hostname: "hello.example.com", port: 4430});
+                return new Promise<void>((resolve, reject) => {
+                    req.on("response", (res) => {
+                        expect(res.statusCode).to.equal(200);
+                        res.on("data", (data) => {
+                            expect(data.toString()).to.equal("signed response!");
+                            resolve();
+                        });
+                    });
+                    req.on("error", (err) => {
+                        reject(err);
+                    });
                     req.end();
                 });
 
@@ -89,25 +92,15 @@ nodeOnly(() => {
                 });
                 await new Promise<void>((resolve) => server.listen(4430, resolve));
 
-                await new Promise<void>((resolve) => {
-                    const req = https.request(
-                        {
-                            hostname: "hello.other.com",
-                            port: 4430,
-                            ca: [constrainedCaCert],
-                            lookup: (hostname, options, callback) => {
-                                if (nodeMajorVersion <= 18) {
-                                    callback(null, "127.0.0.1", 4);
-                                } else {
-                                    callback(null, [{ address: "127.0.0.1", family: 4 }]);
-                                }
-                            },
-                        },
-                    );
+                const req = localhostRequest({hostname: "hello.other.com", port: 4430});
+                return new Promise<void>((resolve, reject) => {
                     req.on("error", (err) => {
                         expect(err.message).to.equal("permitted subtree violation");
                         resolve();
-                    })
+                    });
+                    req.on("response", (res) => {
+                        expect.fail("Unexpected response received");
+                    });
                     req.end();
                 });
             });