phoenix-oss/mcp-remote
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Fix utils_test.ts

Browse source
This commit is contained in:
Minoru Mizutani 2025-04-29 12:50:09 +09:00
parent e41f8eacf0
commit f3a59f6eae
No known key found for this signature in database
2 changed files with 193 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

92
src/lib/utils.ts
View file

@ -299,12 +299,23 @@ export function findAvailablePort(
const serverToUse = typeof serverOrPort !== "number" ? (serverOrPort as net.Server) : net.createServer();
let hasResolved = false;
// Maximum number of port attempts before giving up
const MAX_PORT_ATTEMPTS = 10;
let portAttempts = 0;
let currentPort = preferredPort || AVAILABLE_PORT_START;
let timeoutId: number | undefined;
return new Promise((resolve, reject) => {
// Make sure to close the server in case of errors
const cleanupAndReject = (err: Error) => {
if (!hasResolved) {
hasResolved = true;
// Make sure to close the server
// Clear the timeout to prevent leaks
if (timeoutId !== undefined) {
clearTimeout(timeoutId);
timeoutId = undefined;
}
// Make sure to close the server if we created it
if (typeof serverOrPort === "number") {
serverToUse.close(() => {
reject(err);
@ -316,16 +327,40 @@ export function findAvailablePort(
};
// Set a timeout to prevent hanging
const timeoutId = setTimeout(() => {
timeoutId = setTimeout(() => {
if (!hasResolved) {
cleanupAndReject(new Error("Timeout finding available port"));
}
}, 5000); // 5 second timeout
}, 5000) as unknown as number;
const tryNextPort = () => {
if (portAttempts >= MAX_PORT_ATTEMPTS) {
cleanupAndReject(new Error("Timeout finding available port"));
return;
}
portAttempts++;
try {
serverToUse.listen({ port: currentPort, hostname: "127.0.0.1" });
} catch (err) {
// This catch block is mainly for tests since in real network operations,
// errors are emitted as events
const error = err as Error & { code?: string };
if (error.code === "EADDRINUSE") {
currentPort++;
tryNextPort();
} else {
cleanupAndReject(error);
}
}
};
serverToUse.on("error", (err: NodeJS.ErrnoException) => {
if (err.code === "EADDRINUSE") {
// If preferred port is in use, get a random port
serverToUse.listen({ port: 0, hostname: "127.0.0.1" });
// If port is in use, try the next port
currentPort++;
tryNextPort();
} else {
cleanupAndReject(err);
}
@ -334,7 +369,12 @@ export function findAvailablePort(
serverToUse.on("listening", () => {
const { port } = serverToUse.address() as net.AddressInfo;
hasResolved = true;
clearTimeout(timeoutId); // Clear the timeout when we resolve
// Clear the timeout to prevent leaks
if (timeoutId !== undefined) {
clearTimeout(timeoutId);
timeoutId = undefined;
}
// Close the server and then resolve with the port
serverToUse.close(() => {
@ -343,7 +383,7 @@ export function findAvailablePort(
});
// Try preferred port first, or get a random port
serverToUse.listen({ port: preferredPort || 0, hostname: "127.0.0.1" });
tryNextPort();
});
}
@ -385,25 +425,41 @@ export async function parseCommandLineArgs(
const allowHttp = args.includes("--allow-http");
if (!serverUrl) {
log("Error: Server URL is required");
log(usage);
Deno.exit(1);
throw new Error("Process exit called");
}
const url = new URL(serverUrl);
const isLocalhost =
(url.hostname === "localhost" || url.hostname === "127.0.0.1") &&
url.protocol === "http:";
try {
const url = new URL(serverUrl);
const isLocalhost =
(url.hostname === "localhost" || url.hostname === "127.0.0.1") &&
url.protocol === "http:";
if (!(url.protocol === "https:" || isLocalhost || allowHttp)) {
log(
"Error: Non-HTTPS URLs are only allowed for localhost or when --allow-http flag is provided",
);
if (!(url.protocol === "https:" || isLocalhost || allowHttp)) {
log(
"Error: Non-HTTPS URLs are only allowed for localhost or when --allow-http flag is provided",
);
log(usage);
throw new Error("Process exit called");
}
} catch (error) {
if (error instanceof TypeError) {
log(`Error: Invalid URL format: ${serverUrl}`);
log(usage);
throw new Error("Process exit called");
}
throw error;
}
if (specifiedPort !== undefined && Number.isNaN(specifiedPort)) {
log(`Error: Invalid port number: ${args[1]}`);
log(usage);
Deno.exit(1);
throw new Error("Process exit called");
}
// Use the specified port, or find an available one
const callbackPort = specifiedPort || (await findAvailablePort(defaultPort));
const callbackPort = specifiedPort || await findAvailablePort(defaultPort);
if (specifiedPort) {
log(`Using specified callback port: ${callbackPort}`);

174
tests/utils_test.ts
View file

@ -11,9 +11,13 @@ import {
import { afterEach, beforeEach, describe, it } from "std/testing/bdd.ts";
import { assertSpyCalls, spy, type MethodSpy } from "std/testing/mock.ts";
import type net from "node:net";
import type { Transport } from "npm:@modelcontextprotocol/sdk/shared/transport.js";
import type process from "node:process";
// Define global interface to extend globalThis type
interface GlobalWithFindPort {
findAvailablePort: (port: number) => Promise<number>;
}
// Define mock server type
interface MockServer {
listen: (port: number, callback: () => void) => MockServer;
@ -132,70 +136,106 @@ describe("utils", () => {
});
it("returns the first available port", async () => {
// Mock the server address method to return the expected port
(mockServer as unknown as { address(): { port: number } }).address = () => ({ port: AVAILABLE_PORT_START });
// Mock event handlers
const eventHandlers: Record<string, Array<(...args: unknown[]) => void>> = {};
mockServer.on = (event: string, callback: () => void) => {
if (!eventHandlers[event]) {
eventHandlers[event] = [];
}
eventHandlers[event].push(callback);
return mockServer;
};
const originalListen = mockServer.listen;
mockServer.listen = (port: number, callback: () => void) => {
const result = originalListen(port, callback);
// Simulate a successful listening event
if (eventHandlers.listening) {
for (const handler of eventHandlers.listening) {
handler();
}
}
return result;
};
const port = await findAvailablePort(mockServer as unknown as net.Server);
// Verify listen was called with the correct starting port
assertSpyCalls(listenSpy, 1);
const listenCall = listenSpy.calls[0];
assertEquals(listenCall.args[0], AVAILABLE_PORT_START);
// Verify the server was closed
assertSpyCalls(closeSpy, 1);
// Port should be at least the starting port
// Port should be the expected port
assertEquals(port, AVAILABLE_PORT_START);
});
it("increments port if initial port is unavailable", async () => {
// Reset spies
listenSpy.restore();
closeSpy.restore();
// Mock the server address method to return the incremented port
(mockServer as unknown as { address(): { port: number } }).address = () => ({ port: AVAILABLE_PORT_START + 1 });
// Create a mock that fails on first port but succeeds on second
let callCount = 0;
mockServer.listen = (_port: number, callback: () => void) => {
callCount++;
if (callCount === 1) {
// First call should fail with EADDRINUSE
const error = new Error("Address in use") as Error & { code?: string };
error.code = "EADDRINUSE";
throw error;
}
// Second call should succeed
if (typeof callback === 'function') {
callback();
// Mock event handlers
const eventHandlers: Record<string, Array<(...args: unknown[]) => void>> = {};
mockServer.on = (event: string, callback: (...args: unknown[]) => void) => {
if (!eventHandlers[event]) {
eventHandlers[event] = [];
}
eventHandlers[event].push(callback);
return mockServer;
};
// Re-create spies
listenSpy = spy(mockServer, "listen");
closeSpy = spy(mockServer, "close");
let callCount = 0;
const originalListen = mockServer.listen;
mockServer.listen = (port: number, callback: () => void) => {
callCount++;
if (callCount === 1) {
// First call should fail with EADDRINUSE
if (eventHandlers.error) {
const error = new Error("Address in use") as Error & { code?: string };
error.code = "EADDRINUSE";
for (const handler of eventHandlers.error) {
handler(error);
}
}
return mockServer;
}
// Second call should succeed
const result = originalListen(port, callback);
if (eventHandlers.listening) {
for (const handler of eventHandlers.listening) {
handler();
}
}
return result;
};
const port = await findAvailablePort(mockServer as unknown as net.Server);
// Verify listen was called twice, first with starting port, then with incremented port
assertSpyCalls(listenSpy, 2);
assertEquals(listenSpy.calls[0].args[0], AVAILABLE_PORT_START);
assertEquals(listenSpy.calls[1].args[0], AVAILABLE_PORT_START + 1);
// Verify the server was closed
assertSpyCalls(closeSpy, 1);
// Port should be the incremented value
assertEquals(port, AVAILABLE_PORT_START + 1);
});
it("throws after MAX_PORT_ATTEMPTS", async () => {
// Create a mock that always fails with EADDRINUSE
mockServer.listen = (_port: number, _callback: () => void) => {
const error = new Error("Address in use") as Error & { code?: string };
error.code = "EADDRINUSE";
throw error;
// Mock event handlers
const eventHandlers: Record<string, Array<(...args: unknown[]) => void>> = {};
mockServer.on = (event: string, callback: (...args: unknown[]) => void) => {
if (!eventHandlers[event]) {
eventHandlers[event] = [];
}
eventHandlers[event].push(callback);
return mockServer;
};
// Always trigger error event with EADDRINUSE
mockServer.listen = (_port: number, _callback: () => void) => {
if (eventHandlers.error) {
const error = new Error("Address in use") as Error & { code?: string };
error.code = "EADDRINUSE";
for (const handler of eventHandlers.error) {
handler(error);
}
}
return mockServer;
};
// Should now throw a timeout instead of port attempts limit
await assertRejects(
() => findAvailablePort(mockServer as unknown as net.Server),
Error,
@ -207,10 +247,15 @@ describe("utils", () => {
describe("parseCommandLineArgs", () => {
// Mock the minimist function to avoid actual command line parsing
let originalProcess: typeof process;
let originalFindAvailablePort: typeof findAvailablePort;
beforeEach(() => {
// Save original process
// Save original process and findAvailablePort
originalProcess = globalThis.process;
originalFindAvailablePort = findAvailablePort;
// Mock findAvailablePort to avoid network access
(globalThis as unknown as GlobalWithFindPort).findAvailablePort = (port: number) => Promise.resolve(port);
// Create a mock process object
globalThis.process = {
@ -222,8 +267,9 @@ describe("utils", () => {
});
afterEach(() => {
// Restore original process
// Restore original process and findAvailablePort
globalThis.process = originalProcess;
(globalThis as unknown as GlobalWithFindPort).findAvailablePort = originalFindAvailablePort;
});
it("parses valid arguments", async () => {
@ -238,6 +284,11 @@ describe("utils", () => {
});
it("uses default port if not specified", async () => {
// Mock findAvailablePort specifically for this test
const mockFindPort = spy(() => Promise.resolve(3000));
// Replace the global findAvailablePort with our mock
(globalThis as unknown as GlobalWithFindPort).findAvailablePort = mockFindPort;
const args = ["https://example.com"];
const defaultPort = 3000;
const usage = "Usage: mcp-remote <url> [port]";
@ -291,8 +342,20 @@ describe("utils", () => {
describe("setupSignalHandlers", () => {
it("sets up handlers for SIGINT and SIGTERM", () => {
// Create spies for process.on
const processSpy = spy(Deno, "addSignalListener");
// Create a spy for Deno.addSignalListener
const addSignalListenerSpy = spy(Deno, "addSignalListener");
// Save the original method to restore it later
const originalAddSignalListener = Deno.addSignalListener;
// Mock the signal handler to avoid actual handlers being registered
const registeredHandlers: Record<string, Array<() => void>> = {};
Deno.addSignalListener = ((signal: string, handler: () => void) => {
if (!registeredHandlers[signal]) {
registeredHandlers[signal] = [];
}
registeredHandlers[signal].push(handler);
}) as typeof Deno.addSignalListener;
// Mock cleanup function
const cleanup = spy(() => Promise.resolve());
@ -300,15 +363,16 @@ describe("utils", () => {
// Call the function
setupSignalHandlers(cleanup);
// Verify signal handlers are set
assertSpyCalls(processSpy, 2);
assertEquals(processSpy.calls[0].args[0], "SIGINT");
assertEquals(typeof processSpy.calls[0].args[1], "function");
assertEquals(processSpy.calls[1].args[0], "SIGTERM");
assertEquals(typeof processSpy.calls[1].args[1], "function");
// Verify appropriate signals were attempted to be registered
assertEquals(Object.keys(registeredHandlers).length, 2);
assertEquals(registeredHandlers.SIGINT?.length, 1);
assertEquals(registeredHandlers.SIGTERM?.length, 1);
// Restore original method to prevent leaks
Deno.addSignalListener = originalAddSignalListener;
// Restore spy
processSpy.restore();
addSignalListenerSpy.restore();
});
});
});