@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/admin/__tests__/maintenance.test.ts

@@ -0,0 +1,343 @@
+/**
+ * mysql-mcp - Admin Maintenance Tools Unit Tests
+ * 
+ * Comprehensive tests for maintenance.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createOptimizeTableTool,
+    createAnalyzeTableTool,
+    createCheckTableTool,
+    createRepairTableTool,
+    createFlushTablesTool,
+    createKillQueryTool
+} from '../maintenance.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Admin Maintenance Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createOptimizeTableTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createOptimizeTableTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_optimize_table');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('admin');
+            expect(tool.annotations?.readOnlyHint).toBe(false);
+            expect(tool.annotations?.idempotentHint).toBe(true);
+        });
+
+        it('should execute OPTIMIZE TABLE for single table', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(
+                createMockQueryResult([{ Table: 'users', Op: 'optimize', Msg_type: 'status', Msg_text: 'OK' }])
+            );
+
+            const tool = createOptimizeTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['users'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('OPTIMIZE TABLE `users`');
+            expect(result).toHaveProperty('results');
+            expect(Array.isArray((result as { results: unknown[] }).results)).toBe(true);
+        });
+
+        it('should execute OPTIMIZE TABLE for multiple tables', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createOptimizeTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['users', 'orders', 'products'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('OPTIMIZE TABLE `users`, `orders`, `products`');
+        });
+
+        it('should handle table names with special characters', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createOptimizeTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['table-name', 'table.name'] }, mockContext);
+
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('`table-name`');
+            expect(call).toContain('`table.name`');
+        });
+    });
+
+    describe('createAnalyzeTableTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createAnalyzeTableTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_analyze_table');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('admin');
+            expect(tool.annotations?.idempotentHint).toBe(true);
+        });
+
+        it('should execute ANALYZE TABLE for single table', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(
+                createMockQueryResult([{ Table: 'products', Op: 'analyze', Msg_type: 'status', Msg_text: 'OK' }])
+            );
+
+            const tool = createAnalyzeTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['products'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('ANALYZE TABLE `products`');
+            expect(result).toHaveProperty('results');
+        });
+
+        it('should execute ANALYZE TABLE for multiple tables', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createAnalyzeTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['table1', 'table2'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('ANALYZE TABLE `table1`, `table2`');
+        });
+    });
+
+    describe('createCheckTableTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_check_table');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('read');
+            expect(tool.annotations?.readOnlyHint).toBe(true);
+        });
+
+        it('should execute CHECK TABLE without option', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(
+                createMockQueryResult([{ Table: 'users', Op: 'check', Msg_type: 'status', Msg_text: 'OK' }])
+            );
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['users'] }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('CHECK TABLE `users`');
+            expect(result).toHaveProperty('results');
+            expect(result).toHaveProperty('rowCount');
+        });
+
+        it('should execute CHECK TABLE with EXTENDED option', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['users'], option: 'EXTENDED' }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('CHECK TABLE `users` EXTENDED');
+        });
+
+        it('should execute CHECK TABLE with QUICK option', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['orders'], option: 'QUICK' }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('CHECK TABLE `orders` QUICK');
+        });
+
+        it('should execute CHECK TABLE for multiple tables with option', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['t1', 't2'], option: 'MEDIUM' }, mockContext);
+
+            expect(mockAdapter.rawQuery).toHaveBeenCalledWith('CHECK TABLE `t1`, `t2` MEDIUM');
+        });
+
+        it('should handle empty result rows', async () => {
+            mockAdapter.rawQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['users'] }, mockContext) as { results: unknown[]; rowCount: number };
+
+            expect(result.results).toEqual([]);
+            expect(result.rowCount).toBe(0);
+        });
+
+        it('should handle missing rows property', async () => {
+            mockAdapter.rawQuery.mockResolvedValue({ rows: undefined, rowsAffected: 0, executionTimeMs: 5 });
+
+            const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['users'] }, mockContext) as { results: unknown[]; rowCount: number };
+
+            expect(result.results).toEqual([]);
+            expect(result.rowCount).toBe(0);
+        });
+    });
+
+    describe('createRepairTableTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createRepairTableTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_repair_table');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('admin');
+            expect(tool.annotations?.destructiveHint).toBeUndefined(); // Not destructive
+        });
+
+        it('should execute REPAIR TABLE without QUICK option', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(
+                createMockQueryResult([{ Table: 'myisam_table', Op: 'repair', Msg_type: 'status', Msg_text: 'OK' }])
+            );
+
+            const tool = createRepairTableTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['myisam_table'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('REPAIR TABLE `myisam_table`');
+            expect(result).toHaveProperty('results');
+        });
+
+        it('should execute REPAIR TABLE with QUICK option', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createRepairTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['old_table'], quick: true }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('REPAIR TABLE `old_table` QUICK');
+        });
+
+        it('should default quick to false when not provided', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createRepairTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['table1'] }, mockContext);
+
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).not.toContain('QUICK');
+        });
+
+        it('should execute REPAIR TABLE for multiple tables', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createRepairTableTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['t1', 't2'], quick: false }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('REPAIR TABLE `t1`, `t2`');
+        });
+    });
+
+    describe('createFlushTablesTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_flush_tables');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('admin');
+            expect(tool.annotations?.idempotentHint).toBe(true);
+        });
+
+        it('should execute FLUSH TABLES for all tables when none specified', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('FLUSH TABLES');
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should execute FLUSH TABLES for all tables when undefined', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: undefined }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('FLUSH TABLES');
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should execute FLUSH TABLES for all tables when empty array', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: [] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('FLUSH TABLES');
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should execute FLUSH TABLES for specific table', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ tables: ['users'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('FLUSH TABLES `users`');
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should execute FLUSH TABLES for multiple specific tables', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFlushTablesTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ tables: ['users', 'orders', 'products'] }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('FLUSH TABLES `users`, `orders`, `products`');
+        });
+    });
+
+    describe('createKillQueryTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+
+            expect(tool.name).toBe('mysql_kill_query');
+            expect(tool.group).toBe('admin');
+            expect(tool.requiredScopes).toContain('admin');
+            expect(tool.annotations?.readOnlyHint).toBe(false);
+            expect(tool.annotations?.destructiveHint).toBe(true);
+        });
+
+        it('should execute KILL QUERY by default', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ processId: 12345 }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('KILL QUERY 12345');
+            expect(result).toEqual({ success: true, killed: 12345, type: 'QUERY' });
+        });
+
+        it('should execute KILL QUERY when connection is false', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ processId: 999, connection: false }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('KILL QUERY 999');
+            expect(result).toEqual({ success: true, killed: 999, type: 'QUERY' });
+        });
+
+        it('should execute KILL CONNECTION when connection is true', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({ processId: 54321, connection: true }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith('KILL CONNECTION 54321');
+            expect(result).toEqual({ success: true, killed: 54321, type: 'CONNECTION' });
+        });
+
+        it('should handle various process ID formats', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+
+            // Test with number
+            await tool.handler({ processId: 1 }, mockContext);
+            expect(mockAdapter.executeQuery).toHaveBeenLastCalledWith('KILL QUERY 1');
+
+            // Test with larger number
+            await tool.handler({ processId: 2147483647 }, mockContext);
+            expect(mockAdapter.executeQuery).toHaveBeenLastCalledWith('KILL QUERY 2147483647');
+        });
+    });
+});