test(api): make getFreePort CI checks deterministic

Author: chenjiahan

tests/e2e/api.test.js

@@ -1,10 +1,14 @@
 const path = require('node:path');
+const net = require('node:net');
 const { rspack } = require('@rspack/core');
 const { RspackDevServer: Server } = require('@rspack/dev-server');
 const config = require('../fixtures/client-config/rspack.config');
 const runBrowser = require('../helpers/run-browser');
 const sessionSubscribe = require('../helpers/session-subscribe');
-const { getRandomPorts } = require('../helpers/get-random-port');
+const {
+  getRandomPorts,
+  releaseRandomPorts,
+} = require('../helpers/get-random-port');
 const port = require('../helpers/ports-map').api;
 
 describe('API', () => {
@@ -339,7 +343,7 @@ describe('API', () => {
 
   describe('Server.getFreePort', () => {
     let basePort;
-    let reservedPorts;
+    let reservedPorts = [];
     let dummyServers = [];
     let devServerPort;
 
@@ -367,6 +371,8 @@ describe('API', () => {
         )
         .then(() => {
           dummyServers = [];
+          releaseRandomPorts(reservedPorts);
+          reservedPorts = [];
         });
     });
 
@@ -605,16 +611,50 @@ describe('API', () => {
     });
 
     it("should throw the error when the port isn't found", async () => {
-      rs.doMockRequire(
-        '../../dist/getPort',
-        () => () => Promise.reject(new Error('busy')),
-      );
+      const busyServers = [];
+      const busyPorts = [65534, 65535];
+
+      try {
+        await Promise.all(
+          busyPorts.map(
+            (busyPort) =>
+              new Promise((resolve, reject) => {
+                const server = net.createServer();
+
+                server.unref();
+                server.on('error', reject);
+                server.listen(busyPort, '0.0.0.0', () => {
+                  busyServers.push(server);
+                  resolve();
+                });
+              }),
+          ),
+        );
 
-      process.env.RSPACK_DEV_SERVER_PORT_RETRY = 1;
+        process.env.RSPACK_DEV_SERVER_BASE_PORT = '65534';
+        process.env.RSPACK_DEV_SERVER_PORT_RETRY = 0;
 
-      const { RspackDevServer: Server } = require('@rspack/dev-server');
+        await expect(
+          Server.getFreePort(),
+        ).rejects.toThrowErrorMatchingSnapshot();
+      } finally {
+        await Promise.all(
+          busyServers.map(
+            (server) =>
+              new Promise((resolve, reject) => {
+                server.close((error) => {
+                  if (error) {
+                    reject(error);
+
+                    return;
+                  }
 
-      await expect(Server.getFreePort()).rejects.toThrowErrorMatchingSnapshot();
+                  resolve();
+                });
+              }),
+          ),
+        );
+      }
     });
   });
 

tests/helpers/get-random-port.js

@@ -1,12 +1,15 @@
 const net = require('node:net');
 
-function isPortAvailable(port, host = '0.0.0.0') {
+const minRandomPort = 15000;
+const maxRandomPort = 45000;
+
+async function isPortAvailable(port, host = '0.0.0.0') {
   try {
     const server = net.createServer();
 
     server.unref();
 
-    return new Promise((resolve) => {
+    return await new Promise((resolve) => {
       server.on('listening', () => {
         server.close(() => {
           resolve(true);
@@ -24,33 +27,15 @@ function isPortAvailable(port, host = '0.0.0.0') {
 
 const portMap = new Map();
 
-/**
- * Get a random port.
- * Available port ranges: 1024 ~ 65535
- * `10080` is not available on macOS CI, `> 50000` gets "permission denied" on Windows,
- * so we use `15000` ~ `45000`.
- */
-async function getRandomPort(
-  defaultPort = Math.ceil(Math.random() * 30000) + 15000,
-  host,
-) {
-  let port = defaultPort;
-
-  while (true) {
-    if (!portMap.get(port) && (await isPortAvailable(port, host))) {
-      portMap.set(port, 1);
-
-      return port;
-    }
-
-    port += 1;
-  }
+function getDefaultPort() {
+  return Math.ceil(Math.random() * 30000) + minRandomPort;
 }
 
-async function getRandomPorts(count, host) {
-  let port = await getRandomPort(undefined, host);
+async function findAvailablePort(startPort, count, host) {
+  let port = Math.max(startPort, minRandomPort);
+  const maxStartPort = maxRandomPort - count + 1;
 
-  while (true) {
+  while (port <= maxStartPort) {
     let isAvailable = true;
 
     for (let index = 0; index < count; index += 1) {
@@ -61,27 +46,60 @@ async function getRandomPorts(count, host) {
         !(await isPortAvailable(currentPort, host))
       ) {
         isAvailable = false;
-        port = currentPort + 1;
         break;
       }
     }
 
     if (isAvailable) {
-      const ports = [];
+      return port;
+    }
 
-      for (let index = 0; index < count; index += 1) {
-        const currentPort = port + index;
+    port += 1;
+  }
 
-        portMap.set(currentPort, 1);
-        ports.push(currentPort);
-      }
+  throw new Error('No available ports found');
+}
 
-      return ports;
-    }
+/**
+ * Get a random port.
+ * Available port ranges: 1024 ~ 65535
+ * `10080` is not available on macOS CI, `> 50000` gets "permission denied" on Windows,
+ * so we use `15000` ~ `45000`.
+ */
+async function getRandomPort(defaultPort = getDefaultPort(), host) {
+  const port = await findAvailablePort(defaultPort, 1, host);
+
+  portMap.set(port, 1);
+
+  return port;
+}
+
+async function getRandomPorts(count, host) {
+  if (count < 1) {
+    throw new Error('Port count must be greater than 0');
+  }
+
+  const port = await findAvailablePort(getDefaultPort(), count, host);
+  const ports = [];
+
+  for (let index = 0; index < count; index += 1) {
+    const currentPort = port + index;
+
+    portMap.set(currentPort, 1);
+    ports.push(currentPort);
+  }
+
+  return ports;
+}
+
+function releaseRandomPorts(ports = []) {
+  for (const port of ports) {
+    portMap.delete(port);
   }
 }
 
 module.exports = {
   getRandomPort,
   getRandomPorts,
+  releaseRandomPorts,
 };