mcp-openapi-schema-explorer 1.0.0

package/test/fixtures/sample-v2-api.json

@@ -0,0 +1,39 @@
+{
+  "swagger": "2.0",
+  "info": {
+    "title": "Simple Swagger 2.0 API",
+    "version": "1.0.0",
+    "description": "A simple API definition in Swagger 2.0 format for testing conversion."
+  },
+  "host": "localhost:3000",
+  "basePath": "/v2",
+  "schemes": ["http"],
+  "paths": {
+    "/ping": {
+      "get": {
+        "summary": "Check service health",
+        "description": "Returns a simple pong message.",
+        "produces": ["application/json"],
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "schema": {
+              "$ref": "#/definitions/Pong"
+            }
+          }
+        }
+      }
+    }
+  },
+  "definitions": {
+    "Pong": {
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string",
+          "example": "pong"
+        }
+      }
+    }
+  }
+}

package/test/setup.ts

@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+import path from 'path';
+
+// Extend timeout for E2E tests
+jest.setTimeout(30000);
+
+// Clean up any previous test artifacts
+beforeAll(async () => {
+  // Create required directories if they don't exist
+  const dirs = ['dist', 'dist/src', 'test/fixtures'];
+
+  for (const dir of dirs) {
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (error) {
+      // Ignore if directory already exists
+      if ((error as { code?: string }).code !== 'EEXIST') {
+        throw error;
+      }
+    }
+  }
+
+  // Verify sample OpenAPI spec exists
+  const specPath = path.resolve(process.cwd(), 'test/fixtures/sample-api.json');
+  try {
+    await fs.access(specPath);
+  } catch {
+    throw new Error(`Sample OpenAPI spec not found at ${specPath}`);
+  }
+});
+
+// Custom matchers could be added here if needed

package/test/utils/console-helpers.ts

@@ -0,0 +1,48 @@
+import { jest } from '@jest/globals';
+
+// Define a type for the console.error function signature using unknown
+type ConsoleErrorType = (message?: unknown, ...optionalParams: unknown[]) => void;
+
+/**
+ * Temporarily suppresses console.error messages that match the expected pattern
+ * during the execution of a provided function (typically an async test operation).
+ * Unexpected console.error messages will still be logged.
+ *
+ * @param expectedMessage The exact string or a RegExp to match against the console.error message.
+ * @param fnToRun The async function to execute while suppression is active.
+ * @returns The result of the fnToRun function.
+ */
+export async function suppressExpectedConsoleError<T>(
+  expectedMessage: string | RegExp,
+  fnToRun: () => T | Promise<T>
+): Promise<T> {
+  // Use the defined type for the original function
+  const originalConsoleError: ConsoleErrorType = console.error;
+
+  // Use unknown in the mock implementation signature
+  const consoleErrorSpy = jest
+    .spyOn(console, 'error')
+    .mockImplementation((message?: unknown, ...args: unknown[]) => {
+      const messageStr = String(message); // String conversion handles unknown
+      const shouldSuppress =
+        expectedMessage instanceof RegExp
+          ? expectedMessage.test(messageStr)
+          : messageStr === expectedMessage;
+
+      if (!shouldSuppress) {
+        // Call the original implementation for unexpected errors
+        // We still need to handle the potential type mismatch for the spread
+        // Using Function.prototype.apply is a safer way to call with dynamic args
+        Function.prototype.apply.call(originalConsoleError, console, [message, ...args]);
+      }
+      // If it matches, do nothing (suppress)
+    });
+
+  try {
+    // Execute the function that is expected to trigger the error log
+    return await fnToRun();
+  } finally {
+    // Restore the original console.error
+    consoleErrorSpy.mockRestore();
+  }
+}

package/test/utils/mcp-test-helpers.ts

@@ -0,0 +1,66 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+// import path from 'path';
+
+// Export the interface
+export interface McpTestContext {
+  client: Client;
+  transport: StdioClientTransport;
+  cleanup: () => Promise<void>;
+}
+
+interface StartServerOptions {
+  outputFormat?: 'json' | 'yaml' | 'json-minified';
+}
+
+/**
+ * Start MCP server with test configuration
+ */
+export async function startMcpServer(
+  specPath: string,
+  options: StartServerOptions = {}
+): Promise<McpTestContext> {
+  let transport: StdioClientTransport | undefined;
+  let client: Client | undefined;
+
+  try {
+    // Initialize transport with spec path as argument
+    transport = new StdioClientTransport({
+      command: 'node',
+      args: [
+        'dist/src/index.js',
+        // path.resolve(specPath),
+        specPath,
+        ...(options.outputFormat ? ['--output-format', options.outputFormat] : []),
+      ],
+      stderr: 'inherit', // Pass through server errors normally - they're part of E2E testing
+    });
+
+    // Initialize client
+    client = new Client({
+      name: 'test-client',
+      version: '1.0.0',
+    });
+
+    await client.connect(transport);
+
+    // Create cleanup function
+    const cleanup = async (): Promise<void> => {
+      if (transport) {
+        await transport.close();
+      }
+    };
+
+    return {
+      client,
+      transport,
+      cleanup,
+    };
+  } catch (error) {
+    // Clean up on error
+    if (transport) {
+      await transport.close();
+    }
+    throw error;
+  }
+}

package/test/utils/test-types.ts

@@ -0,0 +1,54 @@
+import { OpenAPIV3 } from 'openapi-types';
+
+export interface EndpointSuccessResponse {
+  method: string;
+  path: string;
+  parameters?: OpenAPIV3.ParameterObject[];
+  requestBody?: OpenAPIV3.RequestBodyObject;
+  responses: { [key: string]: OpenAPIV3.ResponseObject };
+}
+
+export interface EndpointErrorResponse {
+  method: string;
+  path: string;
+  error: string;
+}
+
+export type EndpointResponse = EndpointSuccessResponse | EndpointErrorResponse;
+
+export function isEndpointErrorResponse(obj: unknown): obj is EndpointErrorResponse {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    typeof (obj as EndpointErrorResponse).error === 'string'
+  );
+}
+
+export interface ResourceContent {
+  uri: string;
+  mimeType: string;
+  text: string;
+}
+
+export interface ResourceResponse {
+  contents: ResourceContent[];
+}
+
+// Types for Schema Resource E2E tests
+export type SchemaSuccessResponse = OpenAPIV3.SchemaObject; // Use type alias
+
+export interface SchemaErrorResponse {
+  name: string;
+  error: string;
+}
+
+export type SchemaResponse = SchemaSuccessResponse | SchemaErrorResponse;
+
+export function isSchemaErrorResponse(obj: unknown): obj is SchemaErrorResponse {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    typeof (obj as SchemaErrorResponse).name === 'string' && // Check for name property
+    typeof (obj as SchemaErrorResponse).error === 'string'
+  );
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": true,
+    "rootDir": ".",
+    "lib": ["ES2020"],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "types": ["jest", "node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "local-docs", "test"]
+}

package/tsconfig.test.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules", "dist", "local-docs"]
+}