@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

package/src/adapters/__tests__/DatabaseAdapter.test.ts

@@ -1,441 +1,519 @@
 /**
  * mysql-mcp - DatabaseAdapter Unit Tests
- * 
+ *
  * Tests for the abstract DatabaseAdapter base class methods.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { DatabaseAdapter } from '../DatabaseAdapter.js';
-import type { DatabaseConfig, QueryResult, HealthStatus, SchemaInfo, TableInfo, AdapterCapabilities, ToolDefinition, ResourceDefinition, PromptDefinition, ToolGroup } from '../../types/index.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { DatabaseAdapter } from "../DatabaseAdapter.js";
+import type {
+  DatabaseConfig,
+  QueryResult,
+  HealthStatus,
+  SchemaInfo,
+  TableInfo,
+  AdapterCapabilities,
+  ToolDefinition,
+  ResourceDefinition,
+  PromptDefinition,
+  ToolGroup,
+} from "../../types/index.js";
 
 // Create a concrete implementation for testing
 class TestAdapter extends DatabaseAdapter {
-    readonly type = 'mysql' as const;
-    readonly name = 'Test Adapter';
-    readonly version = '1.0.0';
-
-    private mockQueryResult: QueryResult = { rows: [], rowsAffected: 0 };
-    private mockHealth: HealthStatus = { connected: true, latencyMs: 5 };
-
-    async connect(_config: DatabaseConfig): Promise<void> {
-        this.connected = true;
-    }
-
-    async disconnect(): Promise<void> {
-        this.connected = false;
-    }
-
-    async getHealth(): Promise<HealthStatus> {
-        return this.mockHealth;
-    }
-
-    async executeReadQuery(_sql: string, _params?: unknown[]): Promise<QueryResult> {
-        return this.mockQueryResult;
-    }
-
-    async executeWriteQuery(_sql: string, _params?: unknown[]): Promise<QueryResult> {
-        return this.mockQueryResult;
-    }
-
-    async executeQuery(_sql: string, _params?: unknown[]): Promise<QueryResult> {
-        return this.mockQueryResult;
-    }
-
-    async getSchema(): Promise<SchemaInfo> {
-        return { tables: [], views: [], indexes: [] };
-    }
-
-    async listTables(): Promise<TableInfo[]> {
-        return [];
-    }
-
-    async describeTable(_tableName: string): Promise<TableInfo> {
-        return { name: 'test', type: 'table', columns: [] };
-    }
-
-    async listSchemas(): Promise<string[]> {
-        return ['test'];
-    }
-
-    getCapabilities(): AdapterCapabilities {
-        return {
-            json: true,
-            fullTextSearch: true,
-            vector: false,
-            geospatial: true,
-            transactions: true,
-            preparedStatements: true,
-            connectionPooling: true,
-            partitioning: true,
-            replication: true
-        };
-    }
+  readonly type = "mysql" as const;
+  readonly name = "Test Adapter";
+  readonly version = "1.0.0";
+
+  private mockQueryResult: QueryResult = { rows: [], rowsAffected: 0 };
+  private mockHealth: HealthStatus = { connected: true, latencyMs: 5 };
+
+  async connect(_config: DatabaseConfig): Promise<void> {
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async getHealth(): Promise<HealthStatus> {
+    return this.mockHealth;
+  }
+
+  async executeReadQuery(
+    _sql: string,
+    _params?: unknown[],
+  ): Promise<QueryResult> {
+    return this.mockQueryResult;
+  }
+
+  async executeWriteQuery(
+    _sql: string,
+    _params?: unknown[],
+  ): Promise<QueryResult> {
+    return this.mockQueryResult;
+  }
+
+  async executeQuery(_sql: string, _params?: unknown[]): Promise<QueryResult> {
+    return this.mockQueryResult;
+  }
+
+  async getSchema(): Promise<SchemaInfo> {
+    return { tables: [], views: [], indexes: [] };
+  }
+
+  async listTables(): Promise<TableInfo[]> {
+    return [];
+  }
+
+  async describeTable(_tableName: string): Promise<TableInfo> {
+    return { name: "test", type: "table", columns: [] };
+  }
+
+  async listSchemas(): Promise<string[]> {
+    return ["test"];
+  }
+
+  getCapabilities(): AdapterCapabilities {
+    return {
+      json: true,
+      fullTextSearch: true,
+      vector: false,
+      geospatial: true,
+      transactions: true,
+      preparedStatements: true,
+      connectionPooling: true,
+      partitioning: true,
+      replication: true,
+    };
+  }
+
+  getSupportedToolGroups(): ToolGroup[] {
+    return ["core", "transactions"];
+  }
+
+  getToolDefinitions(): ToolDefinition[] {
+    return [
+      {
+        name: "test_tool",
+        title: "Test Tool",
+        description: "A test tool",
+        group: "core",
+        inputSchema: {},
+        handler: async () => ({ result: "ok" }),
+      },
+    ];
+  }
+
+  getResourceDefinitions(): ResourceDefinition[] {
+    return [
+      {
+        uri: "mysql://test",
+        name: "Test Resource",
+        description: "A test resource",
+        handler: async () => ({ data: "test" }),
+      },
+    ];
+  }
+
+  getPromptDefinitions(): PromptDefinition[] {
+    return [
+      {
+        name: "test_prompt",
+        description: "A test prompt",
+        handler: async () => "Test prompt output",
+      },
+    ];
+  }
+
+  setQueryResult(result: QueryResult): void {
+    this.mockQueryResult = result;
+  }
+}
 
-    getSupportedToolGroups(): ToolGroup[] {
-        return ['core', 'transactions'];
-    }
+describe("DatabaseAdapter", () => {
+  let adapter: TestAdapter;
 
-    getToolDefinitions(): ToolDefinition[] {
-        return [
-            {
-                name: 'test_tool',
-                title: 'Test Tool',
-                description: 'A test tool',
-                group: 'core',
-                inputSchema: {},
-                handler: async () => ({ result: 'ok' })
-            }
-        ];
-    }
-
-    getResourceDefinitions(): ResourceDefinition[] {
-        return [
-            {
-                uri: 'mysql://test',
-                name: 'Test Resource',
-                description: 'A test resource',
-                handler: async () => ({ data: 'test' })
-            }
-        ];
-    }
-
-    getPromptDefinitions(): PromptDefinition[] {
-        return [
-            {
-                name: 'test_prompt',
-                description: 'A test prompt',
-                handler: async () => 'Test prompt output'
-            }
-        ];
-    }
-
-    setQueryResult(result: QueryResult): void {
-        this.mockQueryResult = result;
-    }
-}
+  beforeEach(() => {
+    adapter = new TestAdapter();
+  });
 
-describe('DatabaseAdapter', () => {
-    let adapter: TestAdapter;
+  describe("connection state", () => {
+    it("should start disconnected", () => {
+      expect(adapter.isConnected()).toBe(false);
+    });
 
-    beforeEach(() => {
-        adapter = new TestAdapter();
+    it("should be connected after connect()", async () => {
+      await adapter.connect({
+        type: "mysql",
+        host: "localhost",
+        port: 3306,
+        database: "test",
+        username: "root",
+        password: "",
+      });
+      expect(adapter.isConnected()).toBe(true);
     });
 
-    describe('connection state', () => {
-        it('should start disconnected', () => {
-            expect(adapter.isConnected()).toBe(false);
-        });
+    it("should be disconnected after disconnect()", async () => {
+      await adapter.connect({
+        type: "mysql",
+        host: "localhost",
+        port: 3306,
+        database: "test",
+        username: "root",
+        password: "",
+      });
+      await adapter.disconnect();
+      expect(adapter.isConnected()).toBe(false);
+    });
+  });
 
-        it('should be connected after connect()', async () => {
-            await adapter.connect({ type: 'mysql', host: 'localhost', port: 3306, database: 'test', username: 'root', password: '' });
-            expect(adapter.isConnected()).toBe(true);
-        });
+  describe("adapter info", () => {
+    it("should return correct type", () => {
+      expect(adapter.type).toBe("mysql");
+    });
 
-        it('should be disconnected after disconnect()', async () => {
-            await adapter.connect({ type: 'mysql', host: 'localhost', port: 3306, database: 'test', username: 'root', password: '' });
-            await adapter.disconnect();
-            expect(adapter.isConnected()).toBe(false);
-        });
+    it("should return correct name", () => {
+      expect(adapter.name).toBe("Test Adapter");
     });
 
-    describe('adapter info', () => {
-        it('should return correct type', () => {
-            expect(adapter.type).toBe('mysql');
-        });
+    it("should return correct version", () => {
+      expect(adapter.version).toBe("1.0.0");
+    });
 
-        it('should return correct name', () => {
-            expect(adapter.name).toBe('Test Adapter');
-        });
+    it("should return adapter info object", () => {
+      const info = adapter.getInfo();
+      expect(info["type"]).toBe("mysql");
+      expect(info["name"]).toBe("Test Adapter");
+      expect(info["version"]).toBe("1.0.0");
+      expect(info["connected"]).toBe(false);
+    });
+  });
+
+  describe("capabilities", () => {
+    it("should return capabilities", () => {
+      const caps = adapter.getCapabilities();
+      expect(caps.json).toBe(true);
+      expect(caps.fullTextSearch).toBe(true);
+      expect(caps.transactions).toBe(true);
+    });
 
-        it('should return correct version', () => {
-            expect(adapter.version).toBe('1.0.0');
-        });
+    it("should return supported tool groups", () => {
+      const groups = adapter.getSupportedToolGroups();
+      expect(groups).toContain("core");
+      expect(groups).toContain("transactions");
+    });
+  });
 
-        it('should return adapter info object', () => {
-            const info = adapter.getInfo();
-            expect(info['type']).toBe('mysql');
-            expect(info['name']).toBe('Test Adapter');
-            expect(info['version']).toBe('1.0.0');
-            expect(info['connected']).toBe(false);
-        });
+  describe("definitions", () => {
+    it("should return tool definitions", () => {
+      const tools = adapter.getToolDefinitions();
+      expect(tools.length).toBeGreaterThan(0);
+      expect(tools[0]?.name).toBe("test_tool");
     });
 
-    describe('capabilities', () => {
-        it('should return capabilities', () => {
-            const caps = adapter.getCapabilities();
-            expect(caps.json).toBe(true);
-            expect(caps.fullTextSearch).toBe(true);
-            expect(caps.transactions).toBe(true);
-        });
+    it("should return resource definitions", () => {
+      const resources = adapter.getResourceDefinitions();
+      expect(resources.length).toBeGreaterThan(0);
+      expect(resources[0]?.uri).toBe("mysql://test");
+    });
 
-        it('should return supported tool groups', () => {
-            const groups = adapter.getSupportedToolGroups();
-            expect(groups).toContain('core');
-            expect(groups).toContain('transactions');
-        });
+    it("should return prompt definitions", () => {
+      const prompts = adapter.getPromptDefinitions();
+      expect(prompts.length).toBeGreaterThan(0);
+      expect(prompts[0]?.name).toBe("test_prompt");
     });
+  });
 
-    describe('definitions', () => {
-        it('should return tool definitions', () => {
-            const tools = adapter.getToolDefinitions();
-            expect(tools.length).toBeGreaterThan(0);
-            expect(tools[0]?.name).toBe('test_tool');
-        });
+  describe("request context", () => {
+    it("should create context with default request id", () => {
+      const context = adapter.createContext();
+      expect(context.requestId).toBeTruthy();
+    });
 
-        it('should return resource definitions', () => {
-            const resources = adapter.getResourceDefinitions();
-            expect(resources.length).toBeGreaterThan(0);
-            expect(resources[0]?.uri).toBe('mysql://test');
-        });
+    it("should create context with specified request id", () => {
+      const context = adapter.createContext("test-request-123");
+      expect(context.requestId).toBe("test-request-123");
+    });
+  });
 
-        it('should return prompt definitions', () => {
-            const prompts = adapter.getPromptDefinitions();
-            expect(prompts.length).toBeGreaterThan(0);
-            expect(prompts[0]?.name).toBe('test_prompt');
-        });
+  describe("query validation", () => {
+    it("should allow SELECT queries in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT * FROM users", true),
+      ).not.toThrow();
     });
 
-    describe('request context', () => {
-        it('should create context with default request id', () => {
-            const context = adapter.createContext();
-            expect(context.requestId).toBeTruthy();
-        });
+    it("should reject INSERT in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("INSERT INTO users VALUES (1)", true),
+      ).toThrow();
+    });
 
-        it('should create context with specified request id', () => {
-            const context = adapter.createContext('test-request-123');
-            expect(context.requestId).toBe('test-request-123');
-        });
+    it("should reject UPDATE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery('UPDATE users SET name = "test"', true),
+      ).toThrow();
     });
 
-    describe('query validation', () => {
-        it('should allow SELECT queries in read-only mode', () => {
-            expect(() => adapter.validateQuery('SELECT * FROM users', true)).not.toThrow();
-        });
+    it("should reject DELETE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("DELETE FROM users WHERE id = 1", true),
+      ).toThrow();
+    });
 
-        it('should reject INSERT in read-only mode', () => {
-            expect(() => adapter.validateQuery('INSERT INTO users VALUES (1)', true)).toThrow();
-        });
+    it("should reject DROP in read-only mode", () => {
+      expect(() => adapter.validateQuery("DROP TABLE users", true)).toThrow();
+    });
 
-        it('should reject UPDATE in read-only mode', () => {
-            expect(() => adapter.validateQuery('UPDATE users SET name = "test"', true)).toThrow();
-        });
+    it("should allow write queries in non-read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("INSERT INTO users VALUES (1)", false),
+      ).not.toThrow();
+    });
 
-        it('should reject DELETE in read-only mode', () => {
-            expect(() => adapter.validateQuery('DELETE FROM users WHERE id = 1', true)).toThrow();
-        });
+    it("should reject dangerous patterns", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT * FROM users; DROP TABLE users", false),
+      ).toThrow();
+    });
 
-        it('should reject DROP in read-only mode', () => {
-            expect(() => adapter.validateQuery('DROP TABLE users', true)).toThrow();
-        });
+    it("should reject CREATE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("CREATE TABLE test (id INT)", true),
+      ).toThrow();
+    });
 
-        it('should allow write queries in non-read-only mode', () => {
-            expect(() => adapter.validateQuery('INSERT INTO users VALUES (1)', false)).not.toThrow();
-        });
+    it("should reject ALTER in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery(
+          "ALTER TABLE users ADD column email VARCHAR(255)",
+          true,
+        ),
+      ).toThrow();
+    });
 
-        it('should reject dangerous patterns', () => {
-            expect(() => adapter.validateQuery('SELECT * FROM users; DROP TABLE users', false)).toThrow();
-        });
+    it("should reject TRUNCATE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("TRUNCATE TABLE users", true),
+      ).toThrow();
+    });
 
-        it('should reject CREATE in read-only mode', () => {
-            expect(() => adapter.validateQuery('CREATE TABLE test (id INT)', true)).toThrow();
-        });
+    it("should reject REPLACE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery('REPLACE INTO users VALUES (1, "test")', true),
+      ).toThrow();
+    });
 
-        it('should reject ALTER in read-only mode', () => {
-            expect(() => adapter.validateQuery('ALTER TABLE users ADD column email VARCHAR(255)', true)).toThrow();
-        });
+    it("should reject GRANT in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("GRANT SELECT ON users TO user1", true),
+      ).toThrow();
+    });
 
-        it('should reject TRUNCATE in read-only mode', () => {
-            expect(() => adapter.validateQuery('TRUNCATE TABLE users', true)).toThrow();
-        });
+    it("should reject REVOKE in read-only mode", () => {
+      expect(() =>
+        adapter.validateQuery("REVOKE SELECT ON users FROM user1", true),
+      ).toThrow();
+    });
 
-        it('should reject REPLACE in read-only mode', () => {
-            expect(() => adapter.validateQuery('REPLACE INTO users VALUES (1, "test")', true)).toThrow();
-        });
+    it("should reject empty query", () => {
+      expect(() => adapter.validateQuery("", true)).toThrow(
+        "Query must be a non-empty string",
+      );
+    });
 
-        it('should reject GRANT in read-only mode', () => {
-            expect(() => adapter.validateQuery('GRANT SELECT ON users TO user1', true)).toThrow();
-        });
+    it("should reject non-string query", () => {
+      expect(() => adapter.validateQuery(null as never, true)).toThrow();
+    });
 
-        it('should reject REVOKE in read-only mode', () => {
-            expect(() => adapter.validateQuery('REVOKE SELECT ON users FROM user1', true)).toThrow();
-        });
+    it("should reject SQL comment injection patterns", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT * FROM users --", false),
+      ).toThrow();
+    });
 
-        it('should reject empty query', () => {
-            expect(() => adapter.validateQuery('', true)).toThrow('Query must be a non-empty string');
-        });
+    it("should reject dangerous DELETE pattern", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT 1; DELETE FROM users", false),
+      ).toThrow();
+    });
 
-        it('should reject non-string query', () => {
-            expect(() => adapter.validateQuery(null as never, true)).toThrow();
-        });
+    it("should reject dangerous TRUNCATE pattern", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT 1; TRUNCATE users", false),
+      ).toThrow();
+    });
 
-        it('should reject SQL comment injection patterns', () => {
-            expect(() => adapter.validateQuery('SELECT * FROM users --', false)).toThrow();
-        });
+    it("should reject dangerous INSERT pattern", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT 1; INSERT INTO logs VALUES (1)", false),
+      ).toThrow();
+    });
 
-        it('should reject dangerous DELETE pattern', () => {
-            expect(() => adapter.validateQuery('SELECT 1; DELETE FROM users', false)).toThrow();
-        });
+    it("should reject dangerous UPDATE pattern", () => {
+      expect(() =>
+        adapter.validateQuery("SELECT 1; UPDATE users SET x=1", false),
+      ).toThrow();
+    });
+  });
 
-        it('should reject dangerous TRUNCATE pattern', () => {
-            expect(() => adapter.validateQuery('SELECT 1; TRUNCATE users', false)).toThrow();
-        });
+  describe("MCP registration", () => {
+    let mockServer: {
+      registerTool: ReturnType<typeof vi.fn>;
+      registerResource: ReturnType<typeof vi.fn>;
+      registerPrompt: ReturnType<typeof vi.fn>;
+    };
 
-        it('should reject dangerous INSERT pattern', () => {
-            expect(() => adapter.validateQuery('SELECT 1; INSERT INTO logs VALUES (1)', false)).toThrow();
-        });
+    beforeEach(() => {
+      mockServer = {
+        registerTool: vi.fn(),
+        registerResource: vi.fn(),
+        registerPrompt: vi.fn(),
+      };
+    });
 
-        it('should reject dangerous UPDATE pattern', () => {
-            expect(() => adapter.validateQuery('SELECT 1; UPDATE users SET x=1', false)).toThrow();
-        });
+    describe("registerTools", () => {
+      it("should register enabled tools with server", () => {
+        const enabledTools = new Set(["test_tool"]);
+        adapter.registerTools(mockServer as never, enabledTools);
+        expect(mockServer.registerTool).toHaveBeenCalled();
+      });
+
+      it("should not register tools not in enabled set", () => {
+        const enabledTools = new Set(["other_tool"]);
+        adapter.registerTools(mockServer as never, enabledTools);
+        expect(mockServer.registerTool).not.toHaveBeenCalled();
+      });
+
+      it("should pass tool name and options to server", () => {
+        const enabledTools = new Set(["test_tool"]);
+        adapter.registerTools(mockServer as never, enabledTools);
+
+        expect(mockServer.registerTool).toHaveBeenCalledWith(
+          "test_tool",
+          expect.objectContaining({
+            description: "A test tool",
+            title: "Test Tool",
+          }),
+          expect.any(Function),
+        );
+      });
+    });
+
+    describe("registerResources", () => {
+      it("should register all resources with server", () => {
+        adapter.registerResources(mockServer as never);
+        expect(mockServer.registerResource).toHaveBeenCalled();
+      });
+
+      it("should pass resource name and uri to server", () => {
+        adapter.registerResources(mockServer as never);
+
+        expect(mockServer.registerResource).toHaveBeenCalledWith(
+          "Test Resource",
+          "mysql://test",
+          expect.anything(),
+          expect.any(Function),
+        );
+      });
     });
 
-    describe('MCP registration', () => {
-        let mockServer: {
-            registerTool: ReturnType<typeof vi.fn>;
-            registerResource: ReturnType<typeof vi.fn>;
-            registerPrompt: ReturnType<typeof vi.fn>;
+    describe("registerPrompts", () => {
+      it("should register all prompts with server", () => {
+        adapter.registerPrompts(mockServer as never);
+        expect(mockServer.registerPrompt).toHaveBeenCalled();
+      });
+
+      it("should pass prompt name and description to server", () => {
+        adapter.registerPrompts(mockServer as never);
+
+        expect(mockServer.registerPrompt).toHaveBeenCalledWith(
+          "test_prompt",
+          expect.objectContaining({
+            description: "A test prompt",
+          }),
+          expect.any(Function),
+        );
+      });
+
+      it("should handle prompts with arguments", () => {
+        const promptWithArgs: PromptDefinition = {
+          name: "arg_prompt",
+          description: "desc",
+          arguments: [
+            { name: "required_arg", description: "req", required: true },
+            { name: "optional_arg", description: "opt", required: false },
+          ],
+          handler: async () => "result",
         };
 
-        beforeEach(() => {
-            mockServer = {
-                registerTool: vi.fn(),
-                registerResource: vi.fn(),
-                registerPrompt: vi.fn()
-            };
-        });
+        vi.spyOn(adapter, "getPromptDefinitions").mockReturnValue([
+          promptWithArgs,
+        ]);
+        adapter.registerPrompts(mockServer as never);
+
+        expect(mockServer.registerPrompt).toHaveBeenCalledWith(
+          "arg_prompt",
+          expect.objectContaining({
+            description: "desc",
+            argsSchema: expect.objectContaining({
+              required_arg: expect.anything(),
+              optional_arg: expect.anything(),
+            }),
+          }),
+          expect.any(Function),
+        );
+      });
+    });
 
-        describe('registerTools', () => {
-            it('should register enabled tools with server', () => {
-                const enabledTools = new Set(['test_tool']);
-                adapter.registerTools(mockServer as never, enabledTools);
-                expect(mockServer.registerTool).toHaveBeenCalled();
-            });
-
-            it('should not register tools not in enabled set', () => {
-                const enabledTools = new Set(['other_tool']);
-                adapter.registerTools(mockServer as never, enabledTools);
-                expect(mockServer.registerTool).not.toHaveBeenCalled();
-            });
-
-            it('should pass tool name and options to server', () => {
-                const enabledTools = new Set(['test_tool']);
-                adapter.registerTools(mockServer as never, enabledTools);
-
-                expect(mockServer.registerTool).toHaveBeenCalledWith(
-                    'test_tool',
-                    expect.objectContaining({
-                        description: 'A test tool',
-                        title: 'Test Tool'
-                    }),
-                    expect.any(Function)
-                );
-            });
-        });
+    describe("handler execution", () => {
+      it("should execute tool handler when called", async () => {
+        adapter.registerTools(mockServer as never, new Set(["test_tool"]));
+        // registerTool now takes 3 args: name, options, handler
+        const handler = mockServer.registerTool.mock.calls[0][2] as Function;
 
-        describe('registerResources', () => {
-            it('should register all resources with server', () => {
-                adapter.registerResources(mockServer as never);
-                expect(mockServer.registerResource).toHaveBeenCalled();
-            });
-
-            it('should pass resource name and uri to server', () => {
-                adapter.registerResources(mockServer as never);
-
-                expect(mockServer.registerResource).toHaveBeenCalledWith(
-                    'Test Resource',
-                    'mysql://test',
-                    expect.anything(),
-                    expect.any(Function)
-                );
-            });
+        const result = await handler({});
+        expect(result).toEqual({
+          content: [
+            { type: "text", text: JSON.stringify({ result: "ok" }, null, 2) },
+          ],
         });
+      });
 
+      it("should execute resource handler when called", async () => {
+        adapter.registerResources(mockServer as never);
+        const handler = mockServer.registerResource.mock
+          .calls[0][3] as Function;
 
-        describe('registerPrompts', () => {
-            it('should register all prompts with server', () => {
-                adapter.registerPrompts(mockServer as never);
-                expect(mockServer.registerPrompt).toHaveBeenCalled();
-            });
-
-            it('should pass prompt name and description to server', () => {
-                adapter.registerPrompts(mockServer as never);
-
-                expect(mockServer.registerPrompt).toHaveBeenCalledWith(
-                    'test_prompt',
-                    expect.objectContaining({
-                        description: 'A test prompt'
-                    }),
-                    expect.any(Function)
-                );
-            });
-
-            it('should handle prompts with arguments', () => {
-                const promptWithArgs: PromptDefinition = {
-                    name: 'arg_prompt',
-                    description: 'desc',
-                    arguments: [
-                        { name: 'required_arg', description: 'req', required: true },
-                        { name: 'optional_arg', description: 'opt', required: false }
-                    ],
-                    handler: async () => 'result'
-                };
-
-                vi.spyOn(adapter, 'getPromptDefinitions').mockReturnValue([promptWithArgs]);
-                adapter.registerPrompts(mockServer as never);
-
-                expect(mockServer.registerPrompt).toHaveBeenCalledWith(
-                    'arg_prompt',
-                    expect.objectContaining({
-                        description: 'desc',
-                        argsSchema: expect.objectContaining({
-                            required_arg: expect.anything(),
-                            optional_arg: expect.anything()
-                        })
-                    }),
-                    expect.any(Function)
-                );
-            });
-        });
-
-        describe('handler execution', () => {
-            it('should execute tool handler when called', async () => {
-                adapter.registerTools(mockServer as never, new Set(['test_tool']));
-                // registerTool now takes 3 args: name, options, handler
-                const handler = mockServer.registerTool.mock.calls[0][2] as Function;
-
-                const result = await handler({});
-                expect(result).toEqual({
-                    content: [{ type: 'text', text: JSON.stringify({ result: 'ok' }, null, 2) }]
-                });
-            });
-
-            it('should execute resource handler when called', async () => {
-                adapter.registerResources(mockServer as never);
-                const handler = mockServer.registerResource.mock.calls[0][3] as Function;
-
-                const result = await handler(new URL('mysql://test'));
-                expect(result).toEqual({
-                    contents: [{
-                        uri: 'mysql://test',
-                        mimeType: 'application/json',
-                        text: JSON.stringify({ data: 'test' }, null, 2)
-                    }]
-                });
-            });
-
-            it('should execute prompt handler when called', async () => {
-                adapter.registerPrompts(mockServer as never);
-                // registerPrompt takes 3 args: name, options, handler
-                const handler = mockServer.registerPrompt.mock.calls[0][2] as Function;
-
-                const result = await handler({});
-                expect(result).toEqual({
-                    messages: [{
-                        role: 'user',
-                        content: { type: 'text', text: 'Test prompt output' }
-                    }]
-                });
-            });
+        const result = await handler(new URL("mysql://test"));
+        expect(result).toEqual({
+          contents: [
+            {
+              uri: "mysql://test",
+              mimeType: "application/json",
+              text: JSON.stringify({ data: "test" }, null, 2),
+            },
+          ],
+        });
+      });
+
+      it("should execute prompt handler when called", async () => {
+        adapter.registerPrompts(mockServer as never);
+        // registerPrompt takes 3 args: name, options, handler
+        const handler = mockServer.registerPrompt.mock.calls[0][2] as Function;
+
+        const result = await handler({});
+        expect(result).toEqual({
+          messages: [
+            {
+              role: "user",
+              content: { type: "text", text: "Test prompt output" },
+            },
+          ],
         });
+      });
     });
+  });
 });