Add tests for proxy with unix socket

Author: dometto

bin/configurable-http-proxy

@@ -325,7 +325,7 @@ options.storageBackend = args.storageBackend;
 
 var proxy = new ConfigurableProxy(options);
 
-var listen = parseListenOptions(args);
+var listen = parseListenOptions(args, log);
 
 proxy.proxyServer.listen(...listen.proxyTarget);
 proxy.apiServer.listen(...listen.apiTarget);

lib/configproxy.js

@@ -24,19 +24,19 @@ const require = createRequire(import.meta.url);
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export function parseListenOptions(args) {
+export function parseListenOptions(args, logger) {
   var listen = {};
 
   if (args.socket) {
     listen.proxyTarget = [args.socket];
-    log.warn(
+    logger.warn(
       "Proxy will listen on UNIX domain socket, --ip and --port options will be ignored."
     );
   } else {
     listen.port = parseInt(args.port) || 8000;
     if (args.ip === "*") {
       // handle ip=* alias for all interfaces
-      log.warn(
+      logger.warn(
         "Interpreting ip='*' as all-interfaces. Preferred usage is 0.0.0.0 for all IPv4 or '' for all-interfaces."
       );
       args.ip = "";
@@ -47,7 +47,7 @@ export function parseListenOptions(args) {
 
   if (args.apiSocket) {
     listen.apiSocket = [args.apiSocket];
-    log.warn(
+    logger.warn(
       "API server will listen on UNIX domain socket, --api-ip and --api-port options will be ignored."
     );
   } else {
@@ -57,7 +57,7 @@ export function parseListenOptions(args) {
 
   if (args.metricsSocket) {
     listen.metricsSocket = [args.metricsSocket];
-    log.warn(
+    logger.warn(
       "Metrics server will listen on UNIX domain socket, --metrics-ip and --metrics-port options will be ignored."
     );
   } else if (args.metricsPort) {

lib/testutil.js

@@ -91,7 +91,7 @@ export function setupProxy(listenOptions, options, paths) {
   options = options || {};
   options.authToken = "secret";
   options.log = defaultLogger({ level: "error" });
-  var listen = parseListenOptions(listenOptions);
+  var listen = parseListenOptions(listenOptions, options.log);
   var port = listen.port || 8000;
   var ip = listen.ip;
   var proxy = new ConfigurableProxy(options);

test/proxy_spec.js

@@ -6,6 +6,7 @@ import WebSocket from "ws";
 
 import { ConfigurableProxy } from "../lib/configproxy.js";
 import * as util from "../lib/testutil.js";
+import http from "node:http";
 
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
 
@@ -525,3 +526,84 @@ describe("Proxy Tests", function () {
       .then(done);
   });
 });
+
+
+
+describe("Proxy Tests with Unix socket", function () {
+  var listenOptions = {
+    socket: '/tmp/test.sock',
+  };
+  var requestOptions = new URL('http://localhost')
+  requestOptions.socketPath = listenOptions.socket;
+  var proxy;
+  
+  beforeEach(function (callback) {
+    util.setupProxy(listenOptions).then(function (newProxy) {
+      proxy = newProxy;
+      callback();
+    });
+  });
+
+  afterEach(function (callback) {
+    util.teardownServers(callback);
+  });
+    
+  it("unix socket HTTP request", function (done) {
+      http.request(requestOptions, res => {
+        let recvData = [];
+        res.on('data', chunk => {
+          recvData.push(chunk);
+        });
+        res.on('end', () => {
+          const body = JSON.parse(Buffer.concat(recvData).toString());
+          expect(body).toEqual(
+            jasmine.objectContaining({
+              path: "/",
+            })
+          );
+        });
+        return proxy._routes.get("/").then((route) => {
+          expect(route.last_activity).toBeGreaterThan(proxy._setup_timestamp);
+          done();
+        });
+      }).on('error', err => {
+        console.log('Error: ', err.message);
+        expect("error").toEqual("ok");
+      }).end();
+  });
+
+  it("unix socket WebSocket request", function (done) {
+    var ws = new WebSocket("ws+unix:/tmp/test.sock");
+    ws.on("error", function () {
+      // jasmine fail is only in master
+      expect("error").toEqual("ok");
+      done();
+    });
+    var nmsgs = 0;
+    ws.on("message", function (msg) {
+      msg = msg.toString();
+      if (nmsgs === 0) {
+        expect(msg).toEqual("connected");
+      } else {
+        msg = JSON.parse(msg);
+        expect(msg).toEqual(
+          jasmine.objectContaining({
+            path: "/",
+            message: "hi",
+          })
+        );
+        // check last_activity was updated
+        return proxy._routes.get("/").then((route) => {
+          expect(route.last_activity).toBeGreaterThan(proxy._setup_timestamp);
+          ws.close();
+          done();
+        });
+      }
+      nmsgs++;
+    });
+    ws.on("open", function () {
+      ws.send("hi");
+    });
+  });
+
+});