test fixes

primarily look for x-forwarded-host instead of host header

Author: vhess

lib/test/lib/http-proxy.test.ts

@@ -13,7 +13,7 @@ import { Server } from "socket.io";
 import { io as socketioClient } from "socket.io-client";
 import wait from "../wait";
 import { once } from "node:events";
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeAll } from "vitest";
 
 const ports: { [port: string]: number } = {};
 let portIndex = -1;
@@ -25,13 +25,13 @@ Object.defineProperty(gen, "port", {
   },
 });
 
-describe("setup ports", () => {
-  it("creates some ports", async () => {
+beforeAll(async () => {
+  //creates some ports
     for (let n = 0; n < 50; n++) {
       ports[n] = await getPort();
     }
+
   });
-});
 
 describe("#createProxyServer", () => {
   it("should NOT throw without options -- options are only required later when actually using the proxy", () => {
@@ -46,7 +46,7 @@ describe("#createProxyServer", () => {
     expect(typeof httpProxy.ProxyServer).toBe("function");
     expect(typeof obj).toBe("object");
   });
-});
+
 
 describe("#createProxyServer with forward options and using web-incoming passes", () => {
   it("should pipe the request using web-incoming#stream method", () =>
@@ -55,14 +55,15 @@ describe("#createProxyServer with forward options and using web-incoming passes"
       const proxy = httpProxy
         .createProxyServer({
           forward: "http://127.0.0.1:" + ports.source,
+          xfwd: true
         })
         .listen(ports.proxy);
 
       const source = http
         .createServer((req, res) => {
           res.end();
           expect(req.method).toEqual("GET");
-          expect(req.headers.host?.split(":")[1]).toEqual(`${ports.proxy}`);
+          expect(req.headers["x-forwarded-host"]?.split(":")[1]).toEqual(`${ports.proxy}`);
           source.close();
           proxy.close();
           done();
@@ -82,14 +83,15 @@ describe("#createProxyServer using the web-incoming passes", () => {
       const proxy = httpProxy
         .createProxyServer({
           target: "http://127.0.0.1:" + ports.source,
+          xfwd: true,
         })
         .listen(ports.proxy);
 
       const source = http
         .createServer((req, res) => {
           expect(req.method).toEqual("POST");
-          expect(req.headers["x-forwarded-for"]).toEqual("127.0.0.1");
-          expect(req.headers.host?.split(":")[1]).toEqual(`${ports.proxy}`);
+          expect(req.headers["x-forwarded-for"]).toContain("127.0.0.1");
+          expect((req.headers["x-forwarded-host"] as string).split(":")[1]).toEqual(`${ports.proxy}`);
           res.end();
           source.close();
           proxy.close();
@@ -644,3 +646,4 @@ describe("#createProxyServer using the ws-incoming passes", () => {
       });
     }));
 });
+})

lib/test/lib/https-proxy.test.ts

@@ -4,7 +4,7 @@ import * as https from "node:https";
 import getPort from "../get-port";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeAll } from 'vitest';
 
 const ports: { [port: string]: number } = {};
 let portIndex = -1;
@@ -16,13 +16,15 @@ Object.defineProperty(gen, "port", {
   },
 });
 
-describe("HTTPS to HTTP", () => {
-  it("creates some ports", async () => {
+  beforeAll(async () => {
     for (let n = 0; n < 50; n++) {
       ports[n] = await getPort();
     }
   });
 
+describe("HTTPS to HTTP", () => {
+
+
   it("should proxy the request, then send back the response", () => new Promise<void>(done => {
     const ports = { source: gen.port, proxy: gen.port };
     const source = http
@@ -200,6 +202,7 @@ describe("HTTPS to HTTPS", () => {
 
 describe("HTTPS not allow SSL self signed", () => {
   it("should fail with error", () => new Promise<void>(done => {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = "1";
     const ports = { source: gen.port, proxy: gen.port };
     const source = https
       .createServer({
@@ -221,12 +224,13 @@ describe("HTTPS not allow SSL self signed", () => {
 
     proxy.on("error", (err, _req, res) => {
       res.end();
-      expect(err.toString()).toContain(
-        "Error: unable to verify the first certificate",
+      expect(err.toString()).toMatch(
+        /Error: unable to verify the first certificate|TypeError: fetch failed/,
       );
       source.close();
       proxy.close();
       done();
+     process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
     });
 
     const client = http.request({
@@ -244,7 +248,7 @@ describe("HTTPS to HTTP using own server", () => {
     const source = http
       .createServer((req, res) => {
         expect(req.method).toEqual("GET");
-        expect(req.headers.host?.split(":")[1]).toEqual(`${ports.proxy}`);
+        expect(req.headers["x-forwarded-host"]?.split(":")[1]).toEqual(`${ports.proxy}`);
         res.writeHead(200, { "Content-Type": "text/plain" });
         res.end("Hello from " + ports.source);
       })
@@ -268,6 +272,7 @@ describe("HTTPS to HTTP using own server", () => {
         (req, res) => {
           proxy.web(req, res, {
             target: "http://127.0.0.1:" + ports.source,
+            xfwd: true,
           });
         },
       )

lib/test/middleware/modify-response-middleware.test.ts

@@ -34,8 +34,9 @@ describe("Using the connect-gzip middleware from connect with http-proxy-3", ()
     const rewrite = (_req: http.IncomingMessage, res: http.ServerResponse, next: NextFunction) => {
       const _write = res.write;
       res.write = (data) => {
+        const str = typeof data === "string" ? data : Buffer.from(data).toString();
         // @ts-expect-error write allows 2 args
-        return _write.call(res, data.toString().replace("http-party", "cocalc"))
+        return _write.call(res, str.replace("http-party", "cocalc"))
       };
       next();
     };