/**
* 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';
// 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
};
}
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;
}
}
describe('DatabaseAdapter', () => {
let adapter: TestAdapter;
beforeEach(() => {
adapter = new TestAdapter();
});
describe('connection state', () => {
it('should start disconnected', () => {
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);
});
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);
});
});
describe('adapter info', () => {
it('should return correct type', () => {
expect(adapter.type).toBe('mysql');
});
it('should return correct name', () => {
expect(adapter.name).toBe('Test Adapter');
});
it('should return correct version', () => {
expect(adapter.version).toBe('1.0.0');
});
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 supported tool groups', () => {
const groups = adapter.getSupportedToolGroups();
expect(groups).toContain('core');
expect(groups).toContain('transactions');
});
});
describe('definitions', () => {
it('should return tool definitions', () => {
const tools = adapter.getToolDefinitions();
expect(tools.length).toBeGreaterThan(0);
expect(tools[0]?.name).toBe('test_tool');
});
it('should return resource definitions', () => {
const resources = adapter.getResourceDefinitions();
expect(resources.length).toBeGreaterThan(0);
expect(resources[0]?.uri).toBe('mysql://test');
});
it('should return prompt definitions', () => {
const prompts = adapter.getPromptDefinitions();
expect(prompts.length).toBeGreaterThan(0);
expect(prompts[0]?.name).toBe('test_prompt');
});
});
describe('request context', () => {
it('should create context with default request id', () => {
const context = adapter.createContext();
expect(context.requestId).toBeTruthy();
});
it('should create context with specified request id', () => {
const context = adapter.createContext('test-request-123');
expect(context.requestId).toBe('test-request-123');
});
});
describe('query validation', () => {
it('should allow SELECT queries in read-only mode', () => {
expect(() => adapter.validateQuery('SELECT * FROM users', true)).not.toThrow();
});
it('should reject INSERT in read-only mode', () => {
expect(() => adapter.validateQuery('INSERT INTO users VALUES (1)', true)).toThrow();
});
it('should reject UPDATE in read-only mode', () => {
expect(() => adapter.validateQuery('UPDATE users SET name = "test"', true)).toThrow();
});
it('should reject DELETE in read-only mode', () => {
expect(() => adapter.validateQuery('DELETE FROM users WHERE id = 1', true)).toThrow();
});
it('should reject DROP in read-only mode', () => {
expect(() => adapter.validateQuery('DROP TABLE users', 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 dangerous patterns', () => {
expect(() => adapter.validateQuery('SELECT * FROM users; DROP TABLE users', false)).toThrow();
});
it('should reject CREATE in read-only mode', () => {
expect(() => adapter.validateQuery('CREATE TABLE test (id INT)', 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 TRUNCATE in read-only mode', () => {
expect(() => adapter.validateQuery('TRUNCATE TABLE users', true)).toThrow();
});
it('should reject REPLACE in read-only mode', () => {
expect(() => adapter.validateQuery('REPLACE INTO users VALUES (1, "test")', true)).toThrow();
});
it('should reject GRANT in read-only mode', () => {
expect(() => adapter.validateQuery('GRANT SELECT ON users TO user1', true)).toThrow();
});
it('should reject REVOKE in read-only mode', () => {
expect(() => adapter.validateQuery('REVOKE SELECT ON users FROM user1', true)).toThrow();
});
it('should reject empty query', () => {
expect(() => adapter.validateQuery('', true)).toThrow('Query must be a non-empty string');
});
it('should reject non-string query', () => {
expect(() => adapter.validateQuery(null as never, true)).toThrow();
});
it('should reject SQL comment injection patterns', () => {
expect(() => adapter.validateQuery('SELECT * FROM users --', false)).toThrow();
});
it('should reject dangerous DELETE pattern', () => {
expect(() => adapter.validateQuery('SELECT 1; DELETE FROM users', false)).toThrow();
});
it('should reject dangerous TRUNCATE pattern', () => {
expect(() => adapter.validateQuery('SELECT 1; TRUNCATE 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 UPDATE pattern', () => {
expect(() => adapter.validateQuery('SELECT 1; UPDATE users SET x=1', false)).toThrow();
});
});
describe('MCP registration', () => {
let mockServer: {
registerTool: ReturnType<typeof vi.fn>;
registerResource: ReturnType<typeof vi.fn>;
registerPrompt: ReturnType<typeof vi.fn>;
};
beforeEach(() => {
mockServer = {
registerTool: vi.fn(),
registerResource: vi.fn(),
registerPrompt: vi.fn()
};
});
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('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' }
}]
});
});
});
});
});
