@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/resources/__tests__/locks.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createLocksResource } from '../locks.js';
+
+describe('Locks Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return lock information including waits and statistics', async () => {
+        // Mock data_lock_waits query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            {
+                waiting_trx_id: '100',
+                waiting_thread: 1,
+                waiting_query: 'SELECT * FROM users FOR UPDATE',
+                blocking_trx_id: '101',
+                blocking_thread: 2,
+                blocking_query: 'UPDATE users SET name = "test"',
+                wait_seconds: 5
+            }
+        ]));
+
+        // Mock Innodb_row_lock% status query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Innodb_row_lock_current_waits', Value: '1' },
+            { Variable_name: 'Innodb_row_lock_time', Value: '5000' }
+        ]));
+
+        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://locks', mockContext) as any;
+
+        expect(result.currentLockWaits).toBe(1);
+        expect(result.lockWaits).toHaveLength(1);
+        expect(result.lockWaits[0]).toHaveProperty('waiting_trx_id', '100');
+        expect(result.lockStatistics).toHaveProperty('Innodb_row_lock_current_waits', '1');
+    });
+
+    it('should handle errors gracefully', async () => {
+        mockAdapter.executeQuery.mockRejectedValue(new Error('Database error'));
+
+        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://locks', mockContext) as any;
+
+        expect(result).toHaveProperty('error');
+        expect(result.currentLockWaits).toBe(0);
+        expect(result.lockWaits).toHaveLength(0);
+    });
+
+    it('should handle empty lock stats', async () => {
+        // Mock data_lock_waits query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Mock Innodb_row_lock% status query returning empty or malformed
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://locks', mockContext) as any;
+
+        expect(result.currentLockWaits).toBe(0);
+        expect(result.lockStatistics).toEqual({});
+    });
+
+    it('should handle non-string variable names gracefully', async () => {
+        // Mock data_lock_waits query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Mock Innodb_row_lock% status query with non-string name
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: null, Value: '123' },
+            { Variable_name: 123, Value: '456' },
+            { Variable_name: 'valid_var', Value: '789' }
+        ]));
+
+        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://locks', mockContext) as any;
+
+        expect(result.lockStatistics).toEqual({
+            'valid_var': '789'
+        });
+    });
+    it('should handle undefined rows from query results gracefully', async () => {
+        // Mock data_lock_waits query returning valid result object but with undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({
+            rows: undefined,
+            rowsAffected: 0,
+            executionTimeMs: 0
+        });
+
+        // Mock Innodb_row_lock% status query returning valid result but undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({
+            rows: undefined,
+            rowsAffected: 0,
+            executionTimeMs: 0
+        });
+
+        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://locks', mockContext) as any;
+
+        expect(result.currentLockWaits).toBe(0);
+        expect(result.lockWaits).toEqual([]);
+        expect(result.lockStatistics).toEqual({});
+    });
+});

package/src/adapters/mysql/resources/__tests__/performance.test.ts

@@ -0,0 +1,60 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createPerformanceResource } from '../performance.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('Performance Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return performance metrics', async () => {
+        // Mock status
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Queries', Value: '100000' },
+            { Variable_name: 'Slow_queries', Value: '50' },
+            { Variable_name: 'Select_full_join', Value: '10' },
+            { Variable_name: 'Created_tmp_tables', Value: '1000' },
+            { Variable_name: 'Created_tmp_disk_tables', Value: '100' },
+            { Variable_name: 'Handler_read_key', Value: '50000' },
+            { Variable_name: 'Handler_read_rnd_next', Value: '10000' }
+        ]));
+        // Mock performance schema query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { query_pattern: 'SELECT * FROM users', execution_count: 100, total_time_ms: 500 }
+        ]));
+
+        const resource = createPerformanceResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://performance', mockContext) as { summary: { total_queries: number } };
+
+        expect(result).toHaveProperty('summary');
+        expect(result.summary).toHaveProperty('total_queries', 100000);
+        expect(result.summary).toHaveProperty('slow_queries', 50);
+        expect(result).toHaveProperty('sorts');
+        expect(result).toHaveProperty('joins');
+        expect(result).toHaveProperty('handler');
+        expect(result).toHaveProperty('top_queries');
+    });
+
+    it('should handle missing performance schema', async () => {
+        // Mock status success
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Queries', Value: '500' }
+        ]));
+
+        // Mock performance schema failure
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Table doesn\'t exist'));
+
+        const resource = createPerformanceResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://performance', mockContext) as { summary: object, top_queries: unknown[] };
+
+        expect(result.top_queries).toEqual([]);
+        expect(result.summary).toHaveProperty('total_queries', 500);
+    });
+});

package/src/adapters/mysql/resources/__tests__/pool.test.ts

@@ -0,0 +1,50 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createPoolResource } from '../pool.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+
+interface PoolResult {
+    poolStats?: { total: number; active: number; idle: number };
+    error?: string;
+}
+
+describe('Pool Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return pool statistics when pool available', async () => {
+        (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue({
+            getStats: () => ({
+                total: 10,
+                active: 3,
+                idle: 7,
+                waiting: 0,
+                totalQueries: 500
+            })
+        });
+
+        const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://pool', mockContext) as PoolResult;
+
+        expect(result).toHaveProperty('poolStats');
+        expect(result.poolStats).toHaveProperty('total', 10);
+        expect(result.poolStats).toHaveProperty('active', 3);
+        expect(result.poolStats).toHaveProperty('idle', 7);
+    });
+
+    it('should handle missing pool gracefully', async () => {
+        (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue(null);
+
+        const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://pool', mockContext);
+
+        expect(result).toHaveProperty('error');
+    });
+});

package/src/adapters/mysql/resources/__tests__/processlist.test.ts

@@ -0,0 +1,29 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createProcesslistResource } from '../processlist.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('ProcessList Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should execute SHOW PROCESSLIST query', async () => {
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+            { Id: 1, User: 'root', Host: 'localhost', db: 'test', Command: 'Query', Time: 0, State: 'executing', Info: 'SELECT 1' }
+        ]));
+
+        const resource = createProcesslistResource(mockAdapter as unknown as MySQLAdapter);
+        await resource.handler('mysql://processlist', mockContext);
+
+        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+            expect.stringContaining('PROCESSLIST')
+        );
+    });
+});

package/src/adapters/mysql/resources/__tests__/replication.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createReplicationResource } from '../replication.js';
+
+describe('Replication Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should handle empty result sets gracefully', async () => {
+        // SHOW REPLICA STATUS (returns empty array)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Fallback: SHOW SLAVE STATUS (returns empty array)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW BINARY LOG STATUS (returns empty array)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Fallback: SHOW MASTER STATUS (returns empty array)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // GTID (fails or empty)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('No GTID'));
+
+        // SHOW REPLICAS (empty)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('standalone');
+        expect(result.source).toBeNull();
+        expect(result.replica).toBeNull();
+    });
+
+    it('should return source role info correctly', async () => {
+        // SHOW REPLICA STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not found'));
+        // SHOW SLAVE STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not found'));
+
+        // SHOW BINARY LOG STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { File: 'bin.001', Position: 100, Binlog_Do_DB: '', Binlog_Ignore_DB: '' }
+        ]));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW REPLICAS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Host: 'slave1' }
+        ]));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('source');
+        expect(result.source).toBeDefined();
+        expect(result.connected_replicas).toHaveLength(1);
+    });
+
+    it('should return replica role info correctly', async () => {
+        // SHOW REPLICA STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Source_Host: 'master1', Slave_IO_Running: 'Yes', Slave_SQL_Running: 'Yes', Seconds_Behind_Master: 0 }
+        ]));
+
+        // SHOW BINARY LOG STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not source'));
+        // SHOW MASTER STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not source'));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW REPLICAS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not source'));
+
+        // SHOW SLAVE HOSTS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not source'));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('replica');
+        expect(result.replica).toBeDefined();
+        expect(result.replica.source_host).toBe('master1');
+    });
+
+    it('should handle replica-source role', async () => {
+        // SHOW REPLICA STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Source_Host: 'master1' }
+        ]));
+
+        // SHOW BINARY LOG STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { File: 'bin.001' }
+        ]));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW REPLICAS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('replica-source');
+        expect(result.gtid).toEqual({});
+    });
+
+    it('should parse GTID information', async () => {
+        // SHOW REPLICA STATUS (fail - not a replica)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not a replica'));
+        // SHOW SLAVE STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Not a replica'));
+
+        // SHOW BINARY LOG STATUS (source)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { File: 'bin.001' }
+        ]));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'gtid_mode', Value: 'ON' },
+            { Variable_name: 'gtid_executed', Value: 'uuid:1-100' }
+        ]));
+
+        // SHOW REPLICAS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('source');
+        expect(result.gtid).toEqual({
+            gtid_mode: 'ON',
+            gtid_executed: 'uuid:1-100'
+        });
+    });
+
+    it('should fallback to older syntax for replicas', async () => {
+        // SHOW REPLICA STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Syntax error'));
+
+        // SHOW SLAVE STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Master_Host: 'master1' }
+        ]));
+
+        // SHOW BINARY LOG STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+        // SHOW MASTER STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW REPLICAS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+        // SHOW SLAVE HOSTS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.replica).toBeDefined();
+        expect(result.replica.source_host).toBe('master1');
+    });
+
+    it('should fallback to older syntax for source', async () => {
+        // SHOW REPLICA STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+        // SHOW SLAVE STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+
+        // SHOW BINARY LOG STATUS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+
+        // SHOW MASTER STATUS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { File: 'bin.001' }
+        ]));
+
+        // GTID
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // SHOW REPLICAS (fail)
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('fail'));
+
+        // SHOW SLAVE HOSTS
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Host: 'slave1' }
+        ]));
+
+        const resource = createReplicationResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://replication', mockContext) as any;
+
+        expect(result.role).toBe('source');
+        expect(result.connected_replicas).toHaveLength(1);
+    });
+});

package/src/adapters/mysql/resources/__tests__/resources.test.ts

@@ -0,0 +1,117 @@
+/**
+ * mysql-mcp - Resources Unit Tests
+ * 
+ * Tests for resource definitions using centralized mocks.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getMySQLResources } from '../index.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('getMySQLResources', () => {
+    let resources: ReturnType<typeof getMySQLResources>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        resources = getMySQLResources(createMockMySQLAdapter() as unknown as MySQLAdapter);
+    });
+
+    it('should return 18 resources', () => {
+        expect(resources).toHaveLength(18);
+    });
+
+    it('should have handler functions for all resources', () => {
+        for (const resource of resources) {
+            expect(typeof resource.handler).toBe('function');
+        }
+    });
+
+    it('should have descriptions for all resources', () => {
+        for (const resource of resources) {
+            expect(resource.description).toBeDefined();
+            expect(resource.description.length).toBeGreaterThan(0);
+        }
+    });
+
+    it('should have unique URIs for all resources', () => {
+        const uris = resources.map(r => r.uri);
+        const uniqueUris = new Set(uris);
+        expect(uniqueUris.size).toBe(uris.length);
+    });
+
+    it('should have URIs starting with mysql://', () => {
+        for (const resource of resources) {
+            expect(resource.uri.startsWith('mysql://')).toBe(true);
+        }
+    });
+});
+
+describe('Resource Handler Smoke Tests', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let resources: ReturnType<typeof getMySQLResources>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        resources = getMySQLResources(mockAdapter as unknown as MySQLAdapter);
+    });
+
+    const findResource = (uri: string) => resources.find(r => r.uri === uri);
+
+    it('mysql://tables handler should call listTables', async () => {
+        const resource = findResource('mysql://tables');
+        expect(resource).toBeDefined();
+
+        const result = await resource!.handler('mysql://tables', mockContext);
+        expect(mockAdapter.listTables).toHaveBeenCalled();
+        expect(result).toHaveProperty('tables');
+    });
+
+    it('mysql://schema handler should call getSchema', async () => {
+        const resource = findResource('mysql://schema');
+        expect(resource).toBeDefined();
+
+        const result = await resource!.handler('mysql://schema', mockContext);
+        expect(mockAdapter.getSchema).toHaveBeenCalled();
+        expect(result).toHaveProperty('tables');
+    });
+
+    it('mysql://variables handler should execute query', async () => {
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+            { Variable_name: 'version', Value: '8.0.35' }
+        ]));
+
+        const resource = findResource('mysql://variables');
+        expect(resource).toBeDefined();
+
+        await resource!.handler('mysql://variables', mockContext);
+        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('SHOW'));
+    });
+
+    it('mysql://status handler should execute query', async () => {
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+            { Variable_name: 'Uptime', Value: '86400' }
+        ]));
+
+        const resource = findResource('mysql://status');
+        expect(resource).toBeDefined();
+
+        await resource!.handler('mysql://status', mockContext);
+        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('SHOW'));
+    });
+
+    it('mysql://processlist handler should execute processlist query', async () => {
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+            { Id: 1, User: 'root', Command: 'Query' }
+        ]));
+
+        const resource = findResource('mysql://processlist');
+        expect(resource).toBeDefined();
+
+        await resource!.handler('mysql://processlist', mockContext);
+        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('PROCESSLIST'));
+    });
+});

package/src/adapters/mysql/resources/__tests__/schema.test.ts

@@ -0,0 +1,30 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createSchemaResource } from '../schema.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+
+describe('Schema Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should call getSchema adapter method', async () => {
+        const resource = createSchemaResource(mockAdapter as unknown as MySQLAdapter);
+        await resource.handler('mysql://schema', mockContext);
+
+        expect(mockAdapter.getSchema).toHaveBeenCalled();
+    });
+
+    it('should return schema information', async () => {
+        const resource = createSchemaResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://schema', mockContext);
+
+        expect(result).toHaveProperty('tables');
+    });
+});

package/src/adapters/mysql/resources/__tests__/spatial.test.ts

@@ -0,0 +1,47 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import { createSpatialResource } from '../spatial.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+
+describe('Spatial Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return spatial columns information', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { table_name: 'locations', column_name: 'geom', data_type: 'geometry' }
+        ]));
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // spatial indexes
+
+        const resource = createSpatialResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://spatial', mockContext);
+
+        expect(result).toBeDefined();
+        // @ts-ignore
+        expect(result.spatialColumns).toHaveLength(1);
+        // @ts-ignore
+        expect(result.spatialIndexCount).toBe(0);
+    });
+
+    it('should handle null query results', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Columns
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Indexes
+
+        const resource = createSpatialResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://spatial', mockContext);
+
+        expect(result).toEqual({
+            spatialColumnCount: 0,
+            spatialColumns: [],
+            spatialIndexCount: 0,
+            spatialIndexes: []
+        });
+    });
+});