@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

package/src/adapters/mysql/tools/__tests__/roles.test.ts

@@ -1,217 +1,474 @@
 /**
  * mysql-mcp - Roles Tools Unit Tests
- * 
+ *
  * Tests for roles tool definitions and annotations.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getRoleTools } from '../roles.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 { getRoleTools } from "../roles.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
+
+describe("getRoleTools", () => {
+  let tools: ReturnType<typeof getRoleTools>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRoleTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+  });
+
+  it("should return 8 role tools", () => {
+    expect(tools).toHaveLength(8);
+  });
+
+  it("should have roles group for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.group).toBe("roles");
+    }
+  });
+
+  it("should have handler functions for all tools", () => {
+    for (const tool of tools) {
+      expect(typeof tool.handler).toBe("function");
+    }
+  });
+
+  it("should have inputSchema for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.inputSchema).toBeDefined();
+    }
+  });
+});
 
-describe('getRoleTools', () => {
-    let tools: ReturnType<typeof getRoleTools>;
+describe("Handler Execution", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let tools: ReturnType<typeof getRoleTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRoleTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    tools = getRoleTools(mockAdapter as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
 
-    it('should return 8 role tools', () => {
-        expect(tools).toHaveLength(8);
-    });
+  describe("mysql_role_list", () => {
+    it("should list roles", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ ROLE_NAME: "admin_role" }]),
+      );
 
-    it('should have roles group for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.group).toBe('roles');
-        }
-    });
+      const tool = tools.find((t) => t.name === "mysql_role_list")!;
+      await tool.handler({}, mockContext);
 
-    it('should have handler functions for all tools', () => {
-        for (const tool of tools) {
-            expect(typeof tool.handler).toBe('function');
-        }
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
     });
 
-    it('should have inputSchema for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.inputSchema).toBeDefined();
-        }
-    });
-});
+    it("should list roles with pattern", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ ROLE_NAME: "admin_role" }]),
+      );
 
-describe('Handler Execution', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let tools: ReturnType<typeof getRoleTools>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
+      const tool = tools.find((t) => t.name === "mysql_role_list")!;
+      await tool.handler({ pattern: "admin%" }, mockContext);
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        tools = getRoleTools(mockAdapter as unknown as MySQLAdapter);
-        mockContext = createMockRequestContext();
+      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(call).toContain("LIKE 'admin%'");
     });
+  });
 
-    describe('mysql_role_list', () => {
-        it('should list roles', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(
-                createMockQueryResult([{ ROLE_NAME: 'admin_role' }])
-            );
-
-            const tool = tools.find(t => t.name === 'mysql_role_list')!;
-            await tool.handler({}, mockContext);
+  describe("mysql_role_create", () => {
+    it("should create a role with IF NOT EXISTS default", async () => {
+      // First call: pre-check (role does not exist)
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-        });
-
-        it('should list roles with pattern', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(
-                createMockQueryResult([{ ROLE_NAME: 'admin_role' }])
-            );
+      const tool = tools.find((t) => t.name === "mysql_role_create")!;
+      await tool.handler({ name: "test_role" }, mockContext);
 
-            const tool = tools.find(t => t.name === 'mysql_role_list')!;
-            await tool.handler({ pattern: 'admin%' }, mockContext);
-
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain("LIKE 'admin%'");
-        });
+      // Second call should be the CREATE ROLE
+      const createCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+      expect(createCall).toContain("CREATE ROLE IF NOT EXISTS");
     });
 
-    describe('mysql_role_create', () => {
-        it('should create a role with IF NOT EXISTS default', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_create')!;
-            await tool.handler({ name: 'test_role' }, mockContext);
+    it("should create a role without IF NOT EXISTS", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_create")!;
+      await tool.handler(
+        { name: "test_role", ifNotExists: false },
+        mockContext,
+      );
 
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain('CREATE ROLE IF NOT EXISTS');
-        });
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(call).toContain("CREATE ROLE 'test_role'");
+    });
 
-        it('should create a role without IF NOT EXISTS', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_create')!;
-            await tool.handler({ name: 'test_role', ifNotExists: false }, mockContext);
+    it("should reject invalid role names", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_create")!;
+      await expect(
+        tool.handler({ name: "invalid-role" }, mockContext),
+      ).rejects.toThrow("Invalid role name");
+    });
 
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain("CREATE ROLE 'test_role'");
-        });
+    it("should return skipped when ifNotExists and role already exists", async () => {
+      // Pre-check finds an existing role
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([{ "1": 1 }]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_role_create")!;
+      const result = await tool.handler(
+        { name: "test_role", ifNotExists: true },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: true,
+        skipped: true,
+        roleName: "test_role",
+        reason: "Role already exists",
+      });
+      // Should NOT have issued a CREATE ROLE query
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("mysql_role_grant", () => {
+    it("should grant privileges to role", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_grant")!;
+      await tool.handler(
+        {
+          role: "test_role",
+          privileges: ["SELECT"],
+          database: "testdb",
+          table: "*",
+        },
+        mockContext,
+      );
+
+      expect(mockAdapter.rawQuery).toHaveBeenCalled();
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain("GRANT SELECT ON `testdb`.* TO 'test_role'");
+    });
 
-        it('should reject invalid role names', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_create')!;
-            await expect(tool.handler({ name: 'invalid-role' }, mockContext))
-                .rejects.toThrow('Invalid role name');
-        });
+    it("should handle schema-qualified table name", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_grant")!;
+      await tool.handler(
+        { role: "test_role", privileges: ["SELECT"], table: "testdb.mytable" },
+        mockContext,
+      );
+
+      expect(mockAdapter.rawQuery).toHaveBeenCalled();
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain(
+        "GRANT SELECT ON `testdb`.`mytable` TO 'test_role'",
+      );
     });
 
-    describe('mysql_role_grant', () => {
-        it('should grant privileges to role', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_grant')!;
-            await tool.handler({ role: 'test_role', privileges: ['SELECT'], database: 'testdb', table: '*' }, mockContext);
+    it("should reject invalid role names", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_grant")!;
+      await expect(
+        tool.handler(
+          { role: "invalid-role", privileges: ["SELECT"] },
+          mockContext,
+        ),
+      ).rejects.toThrow("Invalid role name");
+    });
+  });
+
+  describe("mysql_role_revoke", () => {
+    it("should revoke role from user", async () => {
+      // 1: role exists check; 2: user exists check; 3: role_edges assignment check
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]));
+
+      const tool = tools.find((t) => t.name === "mysql_role_revoke")!;
+      await tool.handler(
+        { role: "test_role", user: "testuser", host: "localhost" },
+        mockContext,
+      );
+
+      expect(mockAdapter.rawQuery).toHaveBeenCalled();
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain("REVOKE");
+    });
 
-            expect(mockAdapter.rawQuery).toHaveBeenCalled();
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain("GRANT SELECT ON `testdb`.* TO 'test_role'");
-        });
+    it("should return graceful error when role is not assigned", async () => {
+      // 1: role exists; 2: user exists; 3: role_edges returns empty
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_role_revoke")!;
+      const result = await tool.handler(
+        { role: "test_role", user: "testuser", host: "localhost" },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        role: "test_role",
+        user: "testuser",
+        host: "localhost",
+        reason:
+          "Role 'test_role' is not assigned to user 'testuser'@'localhost'",
+      });
+      expect(mockAdapter.rawQuery).not.toHaveBeenCalled();
+    });
+  });
 
-        it('should handle schema-qualified table name', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_grant')!;
-            await tool.handler({ role: 'test_role', privileges: ['SELECT'], table: 'testdb.mytable' }, mockContext);
+  describe("mysql_role_drop", () => {
+    it("should drop a role with IF EXISTS default", async () => {
+      // First call: pre-check (role exists)
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
-            expect(mockAdapter.rawQuery).toHaveBeenCalled();
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain("GRANT SELECT ON `testdb`.`mytable` TO 'test_role'");
-        });
+      const tool = tools.find((t) => t.name === "mysql_role_drop")!;
+      await tool.handler({ name: "test_role" }, mockContext);
 
-        it('should reject invalid role names', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_grant')!;
-            await expect(tool.handler({ role: 'invalid-role', privileges: ['SELECT'] }, mockContext))
-                .rejects.toThrow('Invalid role name');
-        });
+      // Second call should be the DROP ROLE
+      const dropCall = mockAdapter.executeQuery.mock.calls[1][0] as string;
+      expect(dropCall).toContain("DROP ROLE IF EXISTS");
     });
 
-    describe('mysql_role_revoke', () => {
-        it('should revoke role from user', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_revoke')!;
-            await tool.handler({ role: 'test_role', user: 'testuser', host: 'localhost' }, mockContext);
+    it("should drop a role without IF EXISTS", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_drop")!;
+      await tool.handler({ name: "test_role", ifExists: false }, mockContext);
 
-            expect(mockAdapter.rawQuery).toHaveBeenCalled();
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain('REVOKE');
-        });
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(call).toContain("DROP ROLE 'test_role'");
     });
 
-    describe('mysql_role_drop', () => {
-        it('should drop a role with IF EXISTS default', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_drop')!;
-            await tool.handler({ name: 'test_role' }, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain('DROP ROLE IF EXISTS');
-        });
-
-        it('should drop a role without IF EXISTS', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_drop')!;
-            await tool.handler({ name: 'test_role', ifExists: false }, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain("DROP ROLE 'test_role'");
-        });
+    it("should reject invalid role names", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_drop")!;
+      await expect(
+        tool.handler({ name: "invalid-role" }, mockContext),
+      ).rejects.toThrow("Invalid role name");
+    });
 
-        it('should reject invalid role names', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_drop')!;
-            await expect(tool.handler({ name: 'invalid-role' }, mockContext))
-                .rejects.toThrow('Invalid role name');
-        });
+    it("should return skipped when ifExists and role does not exist", async () => {
+      // Pre-check finds no role
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_role_drop")!;
+      const result = await tool.handler(
+        { name: "test_role", ifExists: true },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: true,
+        skipped: true,
+        roleName: "test_role",
+        reason: "Role did not exist",
+      });
+    });
+  });
+
+  describe("mysql_role_assign", () => {
+    it("should assign role to user", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_assign")!;
+      await tool.handler(
+        { role: "test_role", user: "testuser", host: "localhost" },
+        mockContext,
+      );
+
+      expect(mockAdapter.rawQuery).toHaveBeenCalled();
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain("GRANT");
     });
 
-    describe('mysql_role_assign', () => {
-        it('should assign role to user', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_assign')!;
-            await tool.handler({ role: 'test_role', user: 'testuser', host: 'localhost' }, mockContext);
+    it("should assign role with admin option", async () => {
+      const tool = tools.find((t) => t.name === "mysql_role_assign")!;
+      await tool.handler(
+        {
+          role: "test_role",
+          user: "testuser",
+          host: "localhost",
+          withAdminOption: true,
+        },
+        mockContext,
+      );
+
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain("WITH ADMIN OPTION");
+    });
+  });
 
-            expect(mockAdapter.rawQuery).toHaveBeenCalled();
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain('GRANT');
-        });
+  describe("mysql_role_grants", () => {
+    it("should list grants for a role", async () => {
+      mockAdapter.rawQuery.mockResolvedValue(
+        createMockQueryResult([{ Grants: "SELECT ON *.*" }]),
+      );
 
-        it('should assign role with admin option', async () => {
-            const tool = tools.find(t => t.name === 'mysql_role_assign')!;
-            await tool.handler({ role: 'test_role', user: 'testuser', host: 'localhost', withAdminOption: true }, mockContext);
+      const tool = tools.find((t) => t.name === "mysql_role_grants")!;
+      await tool.handler({ role: "test_role" }, mockContext);
 
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain('WITH ADMIN OPTION');
-        });
+      expect(mockAdapter.rawQuery).toHaveBeenCalled();
+      const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
+      expect(call).toContain("SHOW GRANTS");
     });
+  });
 
-    describe('mysql_role_grants', () => {
-        it('should list grants for a role', async () => {
-            mockAdapter.rawQuery.mockResolvedValue(
-                createMockQueryResult([{ Grants: 'SELECT ON *.*' }])
-            );
+  describe("mysql_user_roles", () => {
+    it("should list roles assigned to user", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ roleName: "admin_role", roleHost: "%" }]),
+      );
 
-            const tool = tools.find(t => t.name === 'mysql_role_grants')!;
-            await tool.handler({ role: 'test_role' }, mockContext);
+      const tool = tools.find((t) => t.name === "mysql_user_roles")!;
+      await tool.handler({ user: "testuser", host: "localhost" }, mockContext);
 
-            expect(mockAdapter.rawQuery).toHaveBeenCalled();
-            const call = mockAdapter.rawQuery.mock.calls[0][0] as string;
-            expect(call).toContain('SHOW GRANTS');
-        });
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(call).toContain("mysql.user");
     });
 
-    describe('mysql_user_roles', () => {
-        it('should list roles assigned to user', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(
-                createMockQueryResult([{ roleName: 'admin_role', roleHost: '%' }])
-            );
+    it("should return exists: false for nonexistent user", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
 
-            const tool = tools.find(t => t.name === 'mysql_user_roles')!;
-            await tool.handler({ user: 'testuser', host: 'localhost' }, mockContext);
+      const tool = tools.find((t) => t.name === "mysql_user_roles")!;
+      const result = await tool.handler(
+        { user: "nonexistent", host: "%" },
+        mockContext,
+      );
 
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-            expect(call).toContain('role_edges');
-        });
+      expect(result).toEqual({
+        user: "nonexistent",
+        host: "%",
+        exists: false,
+      });
+    });
+  });
+
+  describe("mysql_role_create - error handling", () => {
+    it("should return graceful error for duplicate role", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Operation CREATE ROLE failed for 'test_role'@'%'"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_role_create")!;
+      const result = await tool.handler(
+        { name: "test_role", ifNotExists: false },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        reason: "Role 'test_role' already exists",
+      });
+    });
+  });
+
+  describe("mysql_role_drop - error handling", () => {
+    it("should return graceful error for nonexistent role", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Operation DROP ROLE failed for 'test_role'@'%'"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_role_drop")!;
+      const result = await tool.handler(
+        { name: "test_role", ifExists: false },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        reason: "Role 'test_role' does not exist",
+      });
+    });
+  });
+
+  describe("mysql_role_assign - error handling", () => {
+    it("should return graceful error for nonexistent user", async () => {
+      // Role exists check succeeds
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ "1": 1 }]),
+      );
+      // GRANT rawQuery fails with unknown user
+      mockAdapter.rawQuery.mockRejectedValue(
+        new Error("Unknown authorization ID `baduser`@`%`"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_role_assign")!;
+      const result = await tool.handler(
+        { role: "test_role", user: "baduser", host: "%" },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        role: "test_role",
+        user: "baduser",
+        host: "%",
+        error: "User does not exist",
+      });
+    });
+  });
+
+  describe("mysql_role_revoke - error handling", () => {
+    it("should return graceful error for nonexistent user", async () => {
+      // 1: role exists; 2: user does NOT exist
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_role_revoke")!;
+      const result = await tool.handler(
+        { role: "test_role", user: "baduser", host: "%" },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        role: "test_role",
+        user: "baduser",
+        host: "%",
+        error: "User does not exist",
+      });
+      expect(mockAdapter.rawQuery).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("mysql_role_grant - error handling", () => {
+    it("should return graceful error for nonexistent table", async () => {
+      // Role exists check succeeds
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ "1": 1 }]),
+      );
+      // GRANT rawQuery fails with table not found
+      mockAdapter.rawQuery.mockRejectedValue(
+        new Error("Table 'testdb.nonexistent' doesn't exist"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_role_grant")!;
+      const result = await tool.handler(
+        {
+          role: "test_role",
+          privileges: ["SELECT"],
+          database: "testdb",
+          table: "nonexistent",
+        },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        role: "test_role",
+        error: "Table 'testdb.nonexistent' doesn't exist",
+      });
     });
+  });
 });