feat: add test again

Author: bjohansebas

test/server/proxy-option.test.js

@@ -22,6 +22,40 @@ const proxyOptionPathsAsProperties = [
     target: `http://localhost:${port2}`,
     pathRewrite: { "^/api": "" },
   },
+  {
+    context: "/foo",
+    router: (req) => {
+      if (/\.html$/.test(req.path || req.url)) {
+        return "/index.html";
+      }
+
+      return null;
+    },
+  },
+  {
+    context: "/proxy/async",
+    router: async (req, res) => {
+      if (/\/proxy\/async$/.test(req.path || req.url)) {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            res.end("proxy async response");
+            resolve(true);
+          }, 10);
+        });
+      }
+    },
+  },
+  {
+    context: "/bypass-with-target",
+    target: `http://localhost:${port1}`,
+    changeOrigin: true,
+    secure: false,
+    router: (req) => {
+      if (/\.(html)$/i.test(req.path || req.url)) {
+        return req.url;
+      }
+    },
+  },
 ];
 
 const proxyOption = [
@@ -34,7 +68,7 @@ const proxyOption = [
 let maxServerListeners = 0;
 const proxyOptionOfArray = [
   { context: "/proxy1", target: `http://localhost:${port1}` },
-  function proxy(req) {
+  function proxy(req, res, next) {
     if (req) {
       const socket = req.socket || req.connection;
       const server = socket ? socket.server : null;
@@ -49,6 +83,19 @@ const proxyOptionOfArray = [
       context: "/api/proxy2",
       target: `http://localhost:${port2}`,
       pathRewrite: { "^/api": "" },
+      router: () => {
+        if (req) {
+          const resolveUrl = new URL(req.url, `http://${req.headers.host}`);
+          const params = new URLSearchParams(resolveUrl.search);
+          const foo = params.get("foo");
+
+          if (foo) {
+            res.end(`foo+${next.name}+${typeof next}`);
+
+            return false;
+          }
+        }
+      },
     };
   },
 ];
@@ -190,6 +237,55 @@ describe("proxy option", () => {
         expect(response.text).toContain("from proxy2");
       });
     });
+
+    describe("router", () => {
+      it("can rewrite a request path", async () => {
+        const response = await req.get("/foo/bar.html");
+
+        expect(response.status).toBe(200);
+        expect(response.text).toContain("Hello");
+      });
+
+      it("can rewrite a request path regardless of the target defined a bypass option", async () => {
+        const response = await req.get("/baz/hoge.html");
+
+        expect(response.status).toBe(200);
+        expect(response.text).toContain("Hello");
+      });
+
+      it("should pass through a proxy when a bypass function returns null", async () => {
+        const response = await req.get("/foo.js");
+
+        expect(response.status).toBe(200);
+        expect(response.text).toContain("Hey");
+      });
+
+      it("should not pass through a proxy when a bypass function returns false", async () => {
+        const response = await req.get("/proxyfalse");
+
+        expect(response.status).toBe(404);
+      });
+
+      it("should wait if bypass returns promise", async () => {
+        const response = await req.get("/proxy/async");
+
+        expect(response.status).toBe(200);
+        expect(response.text).toContain("proxy async response");
+      });
+
+      it("should work with the 'target' option", async () => {
+        const response = await req.get("/bypass-with-target/foo.js");
+
+        expect(response.status).toBe(404);
+      });
+
+      it("should work with the 'target' option #2", async () => {
+        const response = await req.get("/bypass-with-target/index.html");
+
+        expect(response.status).toBe(200);
+        expect(response.text).toContain("Hello");
+      });
+    });
   });
 
   describe("as an option is an object with the `context` option", () => {
@@ -377,7 +473,7 @@ describe("proxy option", () => {
       const response = await req.get("/api/proxy2?foo=true");
 
       expect(response.statusCode).toBe(200);
-      expect(response.text).toBe("from proxy2");
+      expect(response.text).toBe("foo+next+function");
     });
 
     it("should not exist multiple close events registered", async () => {