@neverinfamous/mysql-mcp 2.1.0

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

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createClusterResource } from '../cluster.js';
+
+describe('Cluster Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return cluster status when group replication is enabled', async () => {
+        // Mock group_replication_group_name
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'group_replication_group_name', Value: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' }
+        ]));
+
+        // Mock replication_group_members
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { id: '1', host: 'host1', port: 3306, state: 'ONLINE', role: 'PRIMARY', version: '8.0.35' },
+            { id: '2', host: 'host2', port: 3306, state: 'ONLINE', role: 'SECONDARY', version: '8.0.35' }
+        ]));
+
+        // Mock primary member query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { host: 'host1', port: 3306 }
+        ]));
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(true);
+        expect(result.groupName).toBe('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee');
+        expect(result.memberCount).toBe(2);
+        expect(result.primary).toBe('host1:3306');
+    });
+
+    it('should return disabled status if group name is empty', async () => {
+        // Mock group_replication_group_name with empty value
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'group_replication_group_name', Value: '' }
+        ]));
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(false);
+        expect(result.message).toContain('not configured');
+    });
+
+    it('should return disabled status if variable query returns empty', async () => {
+        // Mock group_replication_group_name with no rows
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(false);
+    });
+
+    it('should handle undefined rows gracefully', async () => {
+        // Mock empty result with undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(false);
+    });
+
+    it('should handle missing primary member', async () => {
+        // Mock group_replication_group_name
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'group_replication_group_name', Value: 'uuid' }
+        ]));
+
+        // Mock members (no primary)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { id: '1', role: 'SECONDARY' }
+        ]));
+
+        // Mock primary query (empty)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(true);
+        expect(result.primary).toBeNull();
+    });
+
+    it('should handle errors gracefully', async () => {
+        mockAdapter.executeQuery.mockRejectedValue(new Error('DB Error'));
+
+        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://cluster', mockContext) as any;
+
+        expect(result.groupReplicationEnabled).toBe(false);
+        expect(result.message).toContain('Unable to retrieve');
+    });
+});

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

@@ -0,0 +1,97 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createDocstoreResource } from '../docstore.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('createDocstoreResource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let resource: ReturnType<typeof createDocstoreResource>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        resource = createDocstoreResource(mockAdapter as unknown as MySQLAdapter);
+    });
+
+    it('should correctly separate handler logic', () => {
+        expect(resource.name).toBe('Document Store Collections');
+        expect(typeof resource.handler).toBe('function');
+    });
+
+    it('should return correct info when X Plugin is active and collections exist', async () => {
+        // Mock X Plugin status query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { PLUGIN_STATUS: 'ACTIVE' }
+        ]));
+
+        // Mock Collections query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { collection_name: 'users', row_count: 100, size_bytes: 1024 },
+            { collection_name: 'settings', row_count: 5, size_bytes: 512 }
+        ]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            xPluginEnabled: true,
+            collectionCount: 2,
+            collections: [
+                { collection_name: 'users', row_count: 100, size_bytes: 1024 },
+                { collection_name: 'settings', row_count: 5, size_bytes: 512 }
+            ],
+            note: 'X Plugin is active - X Protocol available on port 33060'
+        });
+
+        expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+    });
+
+    it('should return correct info when X Plugin is INACTIVE', async () => {
+        // Mock X Plugin status query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { PLUGIN_STATUS: 'INACTIVE' }
+        ]));
+
+        // Mock Collections query (empty)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            xPluginEnabled: false,
+            collectionCount: 0,
+            collections: [],
+            note: 'X Plugin not active - document store limited to SQL access'
+        });
+    });
+
+    it('should handle undefined rows gracefully', async () => {
+        // Mock X Plugin status query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { PLUGIN_STATUS: 'ACTIVE' }
+        ]));
+
+        // Mock Collections query returning no rows property (e.g. some drivers might not return it)
+        mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
+
+        const result = await resource.handler(resource.uri, mockContext) as any;
+
+        expect(result.collectionCount).toBe(0);
+        expect(result.collections).toEqual([]);
+    });
+
+    it('should handle errors gracefully', async () => {
+        mockAdapter.executeQuery.mockRejectedValue(new Error('Database unavailable'));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            xPluginEnabled: false,
+            collectionCount: 0,
+            collections: [],
+            error: 'Unable to retrieve document store information'
+        });
+    });
+});

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

@@ -0,0 +1,97 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createEventsResource } from '../events.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('createEventsResource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let resource: ReturnType<typeof createEventsResource>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        resource = createEventsResource(mockAdapter as unknown as MySQLAdapter);
+    });
+
+    it('should return scheduler enabled when variable is ON', async () => {
+        // Mock scheduler variable
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'event_scheduler', Value: 'ON' }
+        ]));
+
+        // Mock events list
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { schema_name: 'test', name: 'event1', status: 'ENABLED' }
+        ]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            schedulerEnabled: true,
+            schedulerStatus: 'ON',
+            eventCount: 1,
+            events: [{ schema_name: 'test', name: 'event1', status: 'ENABLED' }]
+        });
+    });
+
+    it('should return scheduler disabled when variable is OFF', async () => {
+        // Mock scheduler variable
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'event_scheduler', Value: 'OFF' }
+        ]));
+
+        // Mock events list
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            schedulerEnabled: false,
+            schedulerStatus: 'OFF',
+            eventCount: 0,
+            events: []
+        });
+    });
+
+    it('should handle missing variable execution gracefully (default OFF)', async () => {
+        // Mock scheduler variable empty result
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Mock events list
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            schedulerEnabled: false,
+            schedulerStatus: 'OFF',
+            eventCount: 0,
+            events: []
+        });
+    });
+
+    it('should propagate errors since no try/catch in handler', async () => {
+        mockAdapter.executeQuery.mockRejectedValue(new Error('DB Error'));
+
+        await expect(resource.handler(resource.uri, mockContext)).rejects.toThrow('DB Error');
+    });
+    it('should handle undefined rows gracefully', async () => {
+        // Mock scheduler variable with undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
+
+        // Mock events list with undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            schedulerEnabled: false,
+            schedulerStatus: 'OFF',
+            eventCount: 0,
+            events: []
+        });
+    });
+});

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

@@ -0,0 +1,92 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import { createHealthResource } from '../health.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+
+describe('Health Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return default values when status variables are missing', async () => {
+        // Empty status result
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+        // Missing max_connections (default 151)
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createHealthResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://health', mockContext) as any;
+
+        expect(result.status).toBe('healthy');
+        expect(result.uptime_seconds).toBe(0);
+        expect(result.connections.current).toBe(0);
+        expect(result.connections.max_allowed).toBe(151); // Default
+        expect(result.connections.usage_percent).toBe(0);
+    });
+
+    it('should handle zero buffer pool requests (avoid div by zero)', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Innodb_buffer_pool_read_requests', Value: '0' },
+            { Variable_name: 'Innodb_buffer_pool_reads', Value: '0' }
+        ]));
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ Value: '100' }]));
+
+        const resource = createHealthResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://health', mockContext) as any;
+
+        expect(result.performance.buffer_pool_hit_ratio).toBe(100);
+    });
+
+    it('should handle zero table lock waits (avoid div by zero)', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Table_locks_waited', Value: '0' },
+            { Variable_name: 'Table_locks_immediate', Value: '0' }
+        ]));
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ Value: '100' }]));
+
+        const resource = createHealthResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://health', mockContext) as any;
+
+        expect(result.performance.table_lock_contention_percent).toBe(0);
+    });
+
+    it('should calculate metrics correctly with values', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Uptime', Value: '3600' },
+            { Variable_name: 'Threads_connected', Value: '50' },
+            { Variable_name: 'Innodb_buffer_pool_read_requests', Value: '100' },
+            { Variable_name: 'Innodb_buffer_pool_reads', Value: '10' }, // 90% hit ratio
+            { Variable_name: 'Table_locks_waited', Value: '20' },
+            { Variable_name: 'Table_locks_immediate', Value: '80' } // 20% contention
+        ]));
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ Value: '100' }])); // Max connections
+
+        const resource = createHealthResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://health', mockContext) as any;
+
+        expect(result.uptime_seconds).toBe(3600);
+        expect(result.connections.usage_percent).toBe(50); // 50/100
+        expect(result.performance.buffer_pool_hit_ratio).toBe(90);
+        expect(result.performance.table_lock_contention_percent).toBe(20);
+    });
+
+    it('should include pool stats if available', async () => {
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+        const mockPool = {
+            getStats: vi.fn().mockReturnValue({ total: 10, active: 5, idle: 5 })
+        };
+        (mockAdapter.getPool as any).mockReturnValue(mockPool);
+
+        const resource = createHealthResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://health', mockContext) as any;
+
+        expect(result.pool).toEqual({ total: 10, active: 5, idle: 5 });
+    });
+});

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

@@ -0,0 +1,106 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createIndexesResource } from '../indexes.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('createIndexesResource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let resource: ReturnType<typeof createIndexesResource>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        resource = createIndexesResource(mockAdapter as unknown as MySQLAdapter);
+    });
+
+    it('should return error if no database selected', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // DB select returns empty/null
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({ error: 'No database selected' });
+    });
+
+    it('should return index stats, unused, and duplicates when all queries succeed', async () => {
+        // Mock Database select
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ db: 'test_db' }]));
+
+        // Mock Index Stats
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { table_name: 'users', index_name: 'PRIMARY', non_unique: 0 }
+        ]));
+
+        // Mock Unused Indexes
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { schema_name: 'test_db', table_name: 'users', index_name: 'idx_old' }
+        ]));
+
+        // Mock Duplicate Indexes
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { table_name: 'users', redundant_index: 'idx_dup', dominant_index: 'PRIMARY' }
+        ]));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            database: 'test_db',
+            total_indexes: 1,
+            indexes: expect.any(Array),
+            unused_indexes: expect.any(Array),
+            potential_duplicates: expect.any(Array)
+        });
+        expect((result as any).indexes).toHaveLength(1);
+        expect((result as any).unused_indexes).toHaveLength(1);
+        expect((result as any).potential_duplicates).toHaveLength(1);
+    });
+
+    it('should handle failures in optional queries (unused/duplicates) gracefully', async () => {
+        // Mock Database select
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ db: 'test_db' }]));
+
+        // Mock Index Stats
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        // Mock Unused Indexes FAILURE
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Performance Schema error'));
+
+        // Mock Duplicate Indexes FAILURE
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Info Schema error'));
+
+        const result = await resource.handler(resource.uri, mockContext);
+
+        expect(result).toEqual({
+            database: 'test_db',
+            total_indexes: 0,
+            indexes: [],
+            unused_indexes: [], // Should default to empty array on error
+            potential_duplicates: [] // Should default to empty array on error
+        });
+    });
+    it('should handle undefined rows gracefully', async () => {
+        // Mock Database select with undefined rows
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
+
+        // First attempt with undefined rows for database selection
+        const result1 = await resource.handler(resource.uri, mockContext);
+        expect(result1).toEqual({ error: 'No database selected' });
+
+        // Now test undefined rows for other queries
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ db: 'test_db' }]));
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any); // Indexes
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any); // Unused
+        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any); // Duplicates
+
+        const result2 = await resource.handler(resource.uri, mockContext);
+        expect(result2).toEqual({
+            database: 'test_db',
+            total_indexes: 0,
+            indexes: [],
+            unused_indexes: [],
+            potential_duplicates: []
+        });
+    });
+});

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

@@ -0,0 +1,74 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createInnodbResource } from '../innodb.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('InnoDB Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return buffer pool statistics', async () => {
+        // Mock buffer pool status
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Innodb_buffer_pool_read_requests', Value: '10000' },
+            { Variable_name: 'Innodb_buffer_pool_reads', Value: '100' },
+            { Variable_name: 'Innodb_buffer_pool_pages_total', Value: '8192' },
+            { Variable_name: 'Innodb_buffer_pool_pages_free', Value: '1000' },
+            { Variable_name: 'Innodb_buffer_pool_pages_data', Value: '7000' },
+            { Variable_name: 'Innodb_buffer_pool_pages_dirty', Value: '50' },
+            { Variable_name: 'Innodb_buffer_pool_write_requests', Value: '5000' }
+        ]));
+        // Mock config
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'innodb_buffer_pool_size', Value: '134217728' },
+            { Variable_name: 'innodb_buffer_pool_instances', Value: '1' }
+        ]));
+        // Mock row operations
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'Innodb_rows_read', Value: '50000' },
+            { Variable_name: 'Innodb_rows_inserted', Value: '1000' }
+        ]));
+
+        const resource = createInnodbResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://innodb', mockContext) as { buffer_pool: { hit_ratio_percent: number } };
+
+
+        expect(result).toHaveProperty('io');
+    });
+
+    it('should handle missing buffer pool stats (division by zero protection)', async () => {
+        // Mock empty stats
+        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+        const resource = createInnodbResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://innodb', mockContext) as any;
+
+        expect(result.buffer_pool.hit_ratio_percent).toBe(100); // Default when requests=0
+        expect(result.buffer_pool.pages.dirty_percent).toBe(0); // Default when total=0
+        expect(result.buffer_pool.size_bytes).toBe(0);
+    });
+
+    it('should parse configuration integers correctly', async () => {
+        mockAdapter.executeQuery
+            .mockResolvedValueOnce(createMockQueryResult([])) // buffer pool stats
+            .mockResolvedValueOnce(createMockQueryResult([ // config
+                { Variable_name: 'innodb_buffer_pool_size', Value: '1024' },
+                { Variable_name: 'innodb_buffer_pool_instances', Value: '2' }
+            ]))
+            .mockResolvedValueOnce(createMockQueryResult([])); // row ops
+
+        const resource = createInnodbResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://innodb', mockContext) as any;
+
+        expect(result.buffer_pool.size_bytes).toBe(1024);
+        expect(result.buffer_pool.instances).toBe(2);
+    });
+});
+