@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

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

@@ -1,92 +1,132 @@
-
-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 });
-    });
+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

@@ -1,106 +1,129 @@
-
-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);
+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),
     });
-
-    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
-        });
+    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: []
-        });
+  });
+  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

@@ -1,74 +1,98 @@
+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";
 
-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>;
 
-describe('InnoDB Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = 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" },
+      ]),
+    );
 
-    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 };
+    };
 
-        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([]));
 
-        expect(result).toHaveProperty('io');
-    });
+    const resource = createInnodbResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://innodb",
+      mockContext,
+    )) as any;
 
-    it('should handle missing buffer pool stats (division by zero protection)', async () => {
-        // Mock empty stats
-        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+    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);
+  });
 
-        const resource = createInnodbResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://innodb', mockContext) as any;
+  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
 
-        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);
-    });
+    const resource = createInnodbResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://innodb",
+      mockContext,
+    )) as any;
 
-    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);
-    });
+    expect(result.buffer_pool.size_bytes).toBe(1024);
+    expect(result.buffer_pool.instances).toBe(2);
+  });
 });
-