feat: enhance JSON serialization safety & add dxt upload limit (#230)

tests/utils/testServerHelper.ts

@@ -0,0 +1,176 @@
+import { Server } from 'http';
+import { AppServer } from '../../src/server.js';
+import { McpSettings } from '../../src/types/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { createMockSettings } from './mockSettings.js';
+import { clearSettingsCache } from '../../src/config/index.js';
+
+/**
+ * Test server helper class for managing AppServer instances during testing
+ */
+export class TestServerHelper {
+  private appServer: AppServer | null = null;
+  private httpServer: Server | null = null;
+  private originalConfigPath: string | null = null;
+  private testConfigPath: string | null = null;
+
+  /**
+   * Creates and initializes a test server with mock settings
+   * @param mockSettings Optional mock settings to use
+   * @returns Object containing server instance and base URL
+   */
+  async createTestServer(mockSettings?: McpSettings): Promise<{
+    appServer: AppServer;
+    httpServer: Server;
+    baseURL: string;
+    port: number;
+  }> {
+    // Use provided mock settings or create default ones
+    const settings = mockSettings || createMockSettings();
+
+    // Create temporary config file for testing
+    await this.setupTemporaryConfig(settings);
+
+    // Create and initialize AppServer
+    this.appServer = new AppServer();
+    await this.appServer.initialize();
+
+    // Wait for server connection with timeout
+    const maxAttempts = 30;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (this.appServer.connected()) {
+        console.log('Test server is ready');
+        break;
+      } else if (attempt === maxAttempts - 1) {
+        throw new Error('Test server did not become ready in time');
+      }
+      console.log(`Waiting for test server to be ready... Attempt ${attempt + 1}/${maxAttempts}`);
+      await delay(3000); // Short delay between checks
+    }
+
+    // Start server on random available port
+    const app = this.appServer.getApp();
+    this.httpServer = app.listen(0);
+
+    const address = this.httpServer.address();
+    const port = typeof address === 'object' && address ? address.port : 3000;
+    const baseURL = `http://localhost:${port}`;
+
+    return {
+      appServer: this.appServer,
+      httpServer: this.httpServer,
+      baseURL,
+      port,
+    };
+  }
+
+  /**
+   * Closes the test server and cleans up temporary files
+   */
+  async closeTestServer(): Promise<void> {
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => {
+        this.httpServer!.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+
+    this.appServer = null;
+
+    // Clean up temporary config file
+    await this.cleanupTemporaryConfig();
+  }
+
+  /**
+   * Sets up a temporary config file for testing
+   * @param settings Mock settings to write to the config file
+   */
+  private async setupTemporaryConfig(settings: McpSettings): Promise<void> {
+    // Store original path if it exists
+    this.originalConfigPath = process.env.MCPHUB_SETTING_PATH || null;
+
+    const configDir = path.join(process.cwd(), 'temp-test-config');
+
+    // Create temp config directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    this.testConfigPath = path.join(configDir, 'mcp_settings.json');
+
+    // Write mock settings to temporary file
+    fs.writeFileSync(this.testConfigPath, JSON.stringify(settings, null, 2));
+
+    // Override the settings path for the test
+    process.env.MCPHUB_SETTING_PATH = this.testConfigPath;
+
+    // Clear settings cache to force re-reading from the new config file
+    clearSettingsCache();
+
+    console.log(`Set test config path: ${this.testConfigPath}`);
+  }
+
+  /**
+   * Cleans up the temporary config file
+   */
+  private async cleanupTemporaryConfig(): Promise<void> {
+    if (this.testConfigPath && fs.existsSync(this.testConfigPath)) {
+      fs.unlinkSync(this.testConfigPath);
+
+      // Try to remove the temp directory if empty
+      const configDir = path.dirname(this.testConfigPath);
+      try {
+        fs.rmdirSync(configDir);
+      } catch (error) {
+        // Ignore error if directory is not empty
+      }
+    }
+
+    // Reset environment variable
+    if (this.originalConfigPath !== null) {
+      process.env.MCPHUB_SETTING_PATH = this.originalConfigPath;
+    } else {
+      delete process.env.MCPHUB_SETTING_PATH;
+    }
+
+    this.testConfigPath = null;
+  }
+}
+
+/**
+ * Waits for a server to be ready by attempting to connect
+ * @param baseURL Base URL of the server
+ * @param maxAttempts Maximum number of connection attempts
+ * @param delay Delay between attempts in milliseconds
+ */
+export const waitForServerReady = async (
+  baseURL: string,
+  maxAttempts = 10,
+  delay = 500,
+): Promise<void> => {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(`${baseURL}/health`);
+      if (response.ok || response.status === 404) {
+        return; // Server is responding
+      }
+    } catch (error) {
+      // Server not ready yet
+    }
+
+    if (i < maxAttempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  throw new Error(`Server at ${baseURL} not ready after ${maxAttempts} attempts`);
+};
+
+/**
+ * Creates a promise that resolves after the specified delay
+ * @param ms Delay in milliseconds
+ */
+export const delay = (ms: number): Promise<void> => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};