/**
* mysql-mcp - MySQL Adapter Mock
*
* Provides mock implementation of MySQLAdapter for testing
* tools, resources, and prompts without database dependency.
*/
import { vi } from 'vitest';
import type { MySQLAdapter } from '../../adapters/mysql/MySQLAdapter.js';
import type { QueryResult, TableInfo, IndexInfo, SchemaInfo, HealthStatus, ColumnInfo } from '../../types/index.js';
/**
* Create a mock query result
*/
export function createMockQueryResult(
rows: Record<string, unknown>[] = [],
affectedRows = 0
): QueryResult {
return {
rows,
rowsAffected: affectedRows,
executionTimeMs: 5
};
}
/**
* Create a mock column info
*/
export function createMockColumnInfo(name: string, type: string, nullable = true, primaryKey = false): ColumnInfo {
return {
name,
type,
nullable,
primaryKey
};
}
/**
* Create a mock table info
*/
export function createMockTableInfo(name: string, rowCount = 100): TableInfo {
return {
name,
type: 'table',
columns: [
createMockColumnInfo('id', 'int', false, true),
createMockColumnInfo('name', 'varchar(255)', true, false),
createMockColumnInfo('created_at', 'datetime', false, false)
],
rowCount,
engine: 'InnoDB',
collation: 'utf8mb4_unicode_ci'
};
}
/**
* Create mock index info
*/
export function createMockIndexInfo(tableName: string, indexName: string): IndexInfo {
return {
name: indexName,
tableName,
columns: ['id'],
unique: indexName === 'PRIMARY',
type: 'BTREE'
};
}
/**
* Create mock schema info
*/
export function createMockSchemaInfo(): SchemaInfo {
return {
tables: [createMockTableInfo('users'), createMockTableInfo('products')],
views: [],
indexes: [createMockIndexInfo('users', 'PRIMARY')]
};
}
/**
* Create mock health status
*/
export function createMockHealthStatus(connected = true): HealthStatus {
return {
connected,
latencyMs: 5,
version: '8.0.35',
poolStats: {
total: 10,
active: 2,
idle: 8,
waiting: 0,
totalQueries: 100
}
};
}
/**
* Create a mock MySQLAdapter
*/
export function createMockMySQLAdapter(): Partial<MySQLAdapter> & {
executeQuery: ReturnType<typeof vi.fn>;
executeReadQuery: ReturnType<typeof vi.fn>;
executeWriteQuery: ReturnType<typeof vi.fn>;
rawQuery: ReturnType<typeof vi.fn>;
getTableIndexes: ReturnType<typeof vi.fn>;
describeTable: ReturnType<typeof vi.fn>;
listTables: ReturnType<typeof vi.fn>;
getSchema: ReturnType<typeof vi.fn>;
} {
const mockQueryResult = createMockQueryResult([{ id: 1, name: 'test' }]);
return {
type: 'mysql' as const,
name: 'MySQL Adapter',
version: '0.1.0',
// Connection methods
connect: vi.fn().mockResolvedValue(undefined),
disconnect: vi.fn().mockResolvedValue(undefined),
getHealth: vi.fn().mockResolvedValue(createMockHealthStatus()),
isConnected: vi.fn().mockReturnValue(true),
// Query execution
executeQuery: vi.fn().mockResolvedValue(mockQueryResult),
executeReadQuery: vi.fn().mockResolvedValue(mockQueryResult),
executeWriteQuery: vi.fn().mockResolvedValue(mockQueryResult),
rawQuery: vi.fn().mockResolvedValue(mockQueryResult),
// Transaction methods
beginTransaction: vi.fn().mockResolvedValue('txn-123'),
commitTransaction: vi.fn().mockResolvedValue(undefined),
rollbackTransaction: vi.fn().mockResolvedValue(undefined),
getTransactionConnection: vi.fn().mockReturnValue(undefined),
// Schema methods
getSchema: vi.fn().mockResolvedValue(createMockSchemaInfo()),
listTables: vi.fn().mockResolvedValue([createMockTableInfo('users')]),
describeTable: vi.fn().mockResolvedValue(createMockTableInfo('users')),
listSchemas: vi.fn().mockResolvedValue(['testdb', 'information_schema']),
getTableIndexes: vi.fn().mockResolvedValue([createMockIndexInfo('users', 'PRIMARY')]),
// Capabilities
getCapabilities: vi.fn().mockReturnValue({
json: true,
fullTextSearch: true,
vector: false,
geospatial: true,
transactions: true,
preparedStatements: true,
connectionPooling: true,
partitioning: true,
replication: true
}),
getSupportedToolGroups: vi.fn().mockReturnValue([
'core', 'transactions', 'json', 'text', 'fulltext',
'performance', 'optimization', 'admin', 'monitoring', 'backup'
]),
// Definition getters
getToolDefinitions: vi.fn().mockReturnValue([]),
getResourceDefinitions: vi.fn().mockReturnValue([]),
getPromptDefinitions: vi.fn().mockReturnValue([]),
// Registration methods (used by McpServer)
registerTools: vi.fn(),
registerResources: vi.fn(),
registerPrompts: vi.fn(),
// Pool access
getPool: vi.fn().mockReturnValue(null)
};
}
/**
* Create a mock RequestContext for handler testing
*/
export function createMockRequestContext(): {
timestamp: Date;
requestId: string;
} {
return {
timestamp: new Date(),
requestId: 'test-request-' + Math.random().toString(36).slice(2, 9)
};
}
/**
* Helper to configure mock adapter response for specific queries
*/
export function configureMockAdapterQuery(
adapter: ReturnType<typeof createMockMySQLAdapter>,
pattern: string,
result: QueryResult
): void {
const originalImpl = adapter.executeQuery.getMockImplementation() as ((sql: string) => Promise<QueryResult>) | undefined;
adapter.executeQuery.mockImplementation((sql: string) => {
if (sql.includes(pattern)) {
return Promise.resolve(result);
}
return originalImpl?.(sql) ?? Promise.resolve(createMockQueryResult());
});
}
/**
* Create a mock MySQLAdapter that returns empty results
*/
export function createMockMySQLAdapterEmpty(): ReturnType<typeof createMockMySQLAdapter> {
const adapter = createMockMySQLAdapter();
const emptyResult = createMockQueryResult([]);
adapter.executeQuery.mockResolvedValue(emptyResult);
adapter.executeReadQuery.mockResolvedValue(emptyResult);
adapter.executeWriteQuery.mockResolvedValue({ rows: [], rowsAffected: 0, executionTimeMs: 1 });
adapter.rawQuery.mockResolvedValue(emptyResult);
return adapter;
}
/**
* Create a mock MySQLAdapter that throws on query execution
*/
export function createMockMySQLAdapterWithError(
errorMessage = 'Database connection failed'
): ReturnType<typeof createMockMySQLAdapter> {
const adapter = createMockMySQLAdapter();
const dbError = new Error(errorMessage);
adapter.executeQuery.mockRejectedValue(dbError);
adapter.executeReadQuery.mockRejectedValue(dbError);
adapter.executeWriteQuery.mockRejectedValue(dbError);
adapter.rawQuery.mockRejectedValue(dbError);
(adapter.getHealth as ReturnType<typeof vi.fn>).mockResolvedValue(createMockHealthStatus(false));
return adapter;
}
/**
* Create a mock adapter for transaction testing with a mock connection
*/
export function createMockMySQLAdapterWithTransaction(): ReturnType<typeof createMockMySQLAdapter> & {
mockConnection: {
query: ReturnType<typeof vi.fn>;
execute: ReturnType<typeof vi.fn>;
release: ReturnType<typeof vi.fn>;
};
} {
const adapter = createMockMySQLAdapter();
const mockConnection = {
query: vi.fn().mockResolvedValue([[], []]),
execute: vi.fn().mockResolvedValue([[], []]),
release: vi.fn()
};
(adapter.getTransactionConnection as ReturnType<typeof vi.fn>).mockReturnValue(mockConnection);
return { ...adapter, mockConnection };
}
/**
* Type alias for the mock adapter return type
*/
export type MockMySQLAdapter = ReturnType<typeof createMockMySQLAdapter>;
