@neverinfamous/mysql-mcp 2.2.0 → 2.3.0

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

@@ -10,7 +10,13 @@ import {
 interface CapabilitiesResult {
   server: {
     version: string;
-    features: { json: boolean; fulltext: boolean; partitioning: boolean };
+    features: {
+      json: boolean;
+      fulltext: boolean;
+      partitioning: boolean;
+      replication: boolean;
+      gtid: boolean;
+    };
   };
   toolGroups: unknown[];
   metaGroups: unknown[];
@@ -64,6 +70,49 @@ describe("Capabilities Resource", () => {
     expect(result.server.features).toHaveProperty("partitioning");
   });
 
+  it("should detect features correctly for MySQL 9.x", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([{ version: "9.6.0" }]),
+    );
+
+    const resource = createCapabilitiesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://capabilities",
+      mockContext,
+    )) as CapabilitiesResult;
+
+    expect(result.server.version).toBe("9.6.0");
+    expect(result.server.features.json).toBe(true);
+    expect(result.server.features.gtid).toBe(true);
+    expect(result.server.features.fulltext).toBe(true);
+    expect(result.server.features.replication).toBe(true);
+    expect(result.server.features.partitioning).toBe(true);
+  });
+
+  it("should disable version-dependent features for unknown version", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([{ version: "unknown" }]),
+    );
+
+    const resource = createCapabilitiesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://capabilities",
+      mockContext,
+    )) as CapabilitiesResult;
+
+    expect(result.server.version).toBe("unknown");
+    expect(result.server.features.json).toBe(false);
+    expect(result.server.features.gtid).toBe(false);
+    // Always-true features remain true
+    expect(result.server.features.fulltext).toBe(true);
+    expect(result.server.features.replication).toBe(true);
+    expect(result.server.features.partitioning).toBe(true);
+  });
+
   it("should have correct metadata", () => {
     const resource = createCapabilitiesResource(
       mockAdapter as unknown as MySQLAdapter,

package/src/adapters/mysql/resources/capabilities.ts

@@ -37,16 +37,18 @@ export function createCapabilitiesResource(
       const version =
         (versionResult.rows?.[0]?.["version"] as string) ?? "unknown";
 
-      // Get available features
+      // Parse major version for feature detection (handles 8.x, 9.x, 10.x+)
+      const majorVersion = parseInt(version.split(".")[0] ?? "0", 10) || 0;
+
       const features = {
-        json: version.startsWith("5.7") || version.startsWith("8."),
+        json: majorVersion >= 8 || version.startsWith("5.7"),
         fulltext: true,
         partitioning: true,
         replication: true,
         gtid:
+          majorVersion >= 8 ||
           version.startsWith("5.6") ||
-          version.startsWith("5.7") ||
-          version.startsWith("8."),
+          version.startsWith("5.7"),
       };
 
       // Get tool groups and meta-groups info

package/src/adapters/mysql/resources/index.ts

@@ -32,7 +32,7 @@ import { createSpatialResource } from "./spatial.js";
 import { createDocstoreResource } from "./docstore.js";
 
 /**
- * Get all MySQL resources (12 total)
+ * Get all MySQL resources (18 total)
  *
  * Core (6):
  * - mysql://schema - Full database schema
@@ -49,6 +49,14 @@ import { createDocstoreResource } from "./docstore.js";
  * - mysql://indexes - Index usage and statistics
  * - mysql://replication - Replication status and lag
  * - mysql://innodb - InnoDB buffer pool and engine metrics
+ *
+ * New (6):
+ * - mysql://events - Event Scheduler status and scheduled events
+ * - mysql://sysschema - sys schema diagnostics summary
+ * - mysql://locks - InnoDB lock contention detection
+ * - mysql://cluster - Group Replication/InnoDB Cluster status
+ * - mysql://spatial - Spatial columns and indexes
+ * - mysql://docstore - Document Store collections
  */
 export function getMySQLResources(adapter: MySQLAdapter): ResourceDefinition[] {
   return [

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

@@ -180,6 +180,40 @@ describe("Handler Execution", () => {
         "txn-123",
       );
     });
+
+    it("should return structured error for nonexistent table", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Table 'testdb.nonexistent' doesn't exist"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_read_query")!;
+      const result = await tool.handler(
+        { query: "SELECT * FROM nonexistent" },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "doesn't exist",
+      );
+    });
+
+    it("should return structured error for non-table errors in read query", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Access denied"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_read_query")!;
+      const result = await tool.handler(
+        { query: "SELECT * FROM users" },
+        mockContext,
+      );
+
+      expect((result as Record<string, unknown>).success).toBe(false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Access denied",
+      );
+    });
   });
 
   describe("mysql_write_query", () => {
@@ -223,6 +257,40 @@ describe("Handler Execution", () => {
         "txn-456",
       );
     });
+
+    it("should return structured error for nonexistent table", async () => {
+      mockAdapter.executeWriteQuery.mockRejectedValue(
+        new Error("Table 'testdb.nonexistent' doesn't exist"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_write_query")!;
+      const result = await tool.handler(
+        { query: "INSERT INTO nonexistent (id) VALUES (1)" },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "doesn't exist",
+      );
+    });
+
+    it("should return structured error for non-table errors in write query", async () => {
+      mockAdapter.executeWriteQuery.mockRejectedValue(
+        new Error("Access denied"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_write_query")!;
+      const result = await tool.handler(
+        { query: "INSERT INTO users VALUES (1)" },
+        mockContext,
+      );
+
+      expect((result as Record<string, unknown>).success).toBe(false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Access denied",
+      );
+    });
   });
 
   describe("mysql_list_tables", () => {

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

@@ -146,6 +146,31 @@ describe("Handler Execution", () => {
       const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
       expect(call).toContain("RENAME TO");
     });
+
+    it("should place RENAME TO before COMMENT and DO body in combined alter", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_event_alter")!;
+      await tool.handler(
+        {
+          name: "old_event",
+          newName: "new_event",
+          body: "SELECT 1",
+          comment: "updated",
+        },
+        mockContext,
+      );
+
+      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      const renameIndex = call.indexOf("RENAME TO");
+      const commentIndex = call.indexOf("COMMENT");
+      const doIndex = call.indexOf("DO ");
+      expect(renameIndex).toBeGreaterThan(-1);
+      expect(commentIndex).toBeGreaterThan(-1);
+      expect(doIndex).toBeGreaterThan(-1);
+      expect(renameIndex).toBeLessThan(commentIndex);
+      expect(commentIndex).toBeLessThan(doIndex);
+    });
   });
 
   describe("mysql_event_drop", () => {
@@ -351,7 +376,9 @@ describe("Event Create Advanced", () => {
   });
 
   it("should add IF NOT EXISTS clause when specified", async () => {
-    mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+    // Pre-check returns empty (event doesn't exist), then CREATE succeeds
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
     const tool = tools.find((t) => t.name === "mysql_event_create")!;
     await tool.handler(
@@ -364,10 +391,37 @@ describe("Event Create Advanced", () => {
       mockContext,
     );
 
-    const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+    const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
     expect(call).toContain("IF NOT EXISTS");
   });
 
+  it("should return skipped when ifNotExists is true and event already exists", async () => {
+    // Pre-check returns existing event
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ EVENT_NAME: "my_event" }]),
+    );
+
+    const tool = tools.find((t) => t.name === "mysql_event_create")!;
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
+        body: "DELETE FROM temp",
+        ifNotExists: true,
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: true,
+      skipped: true,
+      reason: "Event already exists",
+      eventName: "my_event",
+    });
+    // Should only have the pre-check query, no CREATE
+    expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+  });
+
   it("should include STARTS and ENDS for recurring events", async () => {
     mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
 

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

@@ -123,7 +123,7 @@ describe("JSON Core Handler Execution", () => {
         {
           table: "users",
           column: "metadata",
-          candidate: { key: "value" },
+          value: { key: "value" },
         },
         mockContext,
       );

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

@@ -72,19 +72,61 @@ describe("JSON Helper Handler Execution", () => {
   });
 
   describe("mysql_json_validate", () => {
-    it("should validate JSON value", async () => {
+    it("should validate valid JSON", async () => {
       mockAdapter.executeReadQuery.mockResolvedValue(
         createMockQueryResult([{ is_valid: 1 }]),
       );
 
       const tool = tools.find((t) => t.name === "mysql_json_validate")!;
-      const result = await tool.handler(
+      const result = (await tool.handler(
         { value: '{"name":"test"}' },
         mockContext,
-      );
+      )) as { valid: boolean };
 
       expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
-      expect(result).toBeDefined();
+      expect(result.valid).toBe(true);
+    });
+
+    it("should return valid: false for malformed JSON", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ is_valid: 0 }]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_json_validate")!;
+      const result = (await tool.handler(
+        { value: '{"broken": true' },
+        mockContext,
+      )) as { valid: boolean };
+
+      expect(result.valid).toBe(false);
+    });
+
+    it("should return valid: false for bare strings", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ is_valid: 0 }]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_json_validate")!;
+      const result = (await tool.handler({ value: "hello" }, mockContext)) as {
+        valid: boolean;
+      };
+
+      expect(result.valid).toBe(false);
+    });
+
+    it("should return structured error on MySQL failure", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Validation query failed"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_json_validate")!;
+      const result = (await tool.handler(
+        { value: "\x00invalid" },
+        mockContext,
+      )) as { valid: boolean; error: string };
+
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Validation query failed");
     });
   });
 

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

@@ -297,7 +297,9 @@ describe("Partitioning Handler Execution", () => {
 
   describe("mysql_add_partition", () => {
     it("should add a RANGE partition", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       const result = await tool.handler(
@@ -310,15 +312,19 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      expect(mockAdapter.executeQuery).toHaveBeenCalled();
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("ADD PARTITION");
       expect(call).toContain("VALUES LESS THAN");
       expect(result).toHaveProperty("success", true);
     });
 
     it("should add a LIST partition", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ TABLE_NAME: "regions" }]),
+        )
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       await tool.handler(
@@ -331,12 +337,14 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("VALUES IN");
     });
 
     it("should add HASH partitions", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "data" }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       await tool.handler(
@@ -349,12 +357,14 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("PARTITIONS 4");
     });
 
     it("should add KEY partitions", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "data" }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       await tool.handler(
@@ -367,14 +377,16 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("PARTITIONS 8");
     });
   });
 
   describe("mysql_drop_partition", () => {
     it("should drop a partition", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_drop_partition")!;
       const result = await tool.handler(
@@ -385,8 +397,8 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      expect(mockAdapter.executeQuery).toHaveBeenCalled();
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("DROP PARTITION");
       expect(result).toHaveProperty("success", true);
     });
@@ -394,7 +406,9 @@ describe("Partitioning Handler Execution", () => {
 
   describe("mysql_reorganize_partition", () => {
     it("should reorganize partitions", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockResolvedValueOnce(createMockQueryResult([]));
 
       const tool = tools.find((t) => t.name === "mysql_reorganize_partition")!;
       const result = await tool.handler(
@@ -410,18 +424,20 @@ describe("Partitioning Handler Execution", () => {
         mockContext,
       );
 
-      expect(mockAdapter.executeQuery).toHaveBeenCalled();
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
       expect(call).toContain("REORGANIZE PARTITION");
       expect(result).toHaveProperty("success", true);
     });
 
     it("should return structured error for non-partitioned table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error(
-          "Partition management on a not partitioned table is not possible",
-        ),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "users" }]))
+        .mockRejectedValueOnce(
+          new Error(
+            "Partition management on a not partitioned table is not possible",
+          ),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_reorganize_partition")!;
       const result = (await tool.handler(
@@ -439,9 +455,11 @@ describe("Partitioning Handler Execution", () => {
     });
 
     it("should return structured error for nonexistent partition", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error("Error in list of partitions to REORGANIZE"),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockRejectedValueOnce(
+          new Error("Error in list of partitions to REORGANIZE"),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_reorganize_partition")!;
       const result = (await tool.handler(
@@ -458,6 +476,76 @@ describe("Partitioning Handler Execution", () => {
       expect(result.fromPartitions).toEqual(["nonexistent"]);
       expect(result.error).toContain("do not exist");
     });
+
+    it("should return structured error for unsupported partition type (HASH)", async () => {
+      const tool = tools.find((t) => t.name === "mysql_reorganize_partition")!;
+      const result = (await tool.handler(
+        {
+          table: "data",
+          fromPartitions: ["p1"],
+          partitionType: "HASH",
+          toPartitions: [{ name: "p1a", value: "50" }],
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("HASH/KEY");
+      expect(result.error).toContain("cannot be reorganized");
+      // Should NOT have called executeQuery — error caught at validation
+      expect(mockAdapter.executeQuery).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Partitioning P154 existence checks", () => {
+    it("should return exists: false for nonexistent table in add_partition", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_add_partition")!;
+      const result = (await tool.handler(
+        {
+          table: "nonexistent",
+          partitionName: "p1",
+          partitionType: "RANGE",
+          value: "100",
+        },
+        mockContext,
+      )) as { exists: boolean; table: string };
+
+      expect(result.exists).toBe(false);
+      expect(result.table).toBe("nonexistent");
+    });
+
+    it("should return exists: false for nonexistent table in drop_partition", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_drop_partition")!;
+      const result = (await tool.handler(
+        { table: "nonexistent", partitionName: "p1" },
+        mockContext,
+      )) as { exists: boolean; table: string };
+
+      expect(result.exists).toBe(false);
+      expect(result.table).toBe("nonexistent");
+    });
+
+    it("should return exists: false for nonexistent table in reorganize_partition", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_reorganize_partition")!;
+      const result = (await tool.handler(
+        {
+          table: "nonexistent",
+          fromPartitions: ["p1"],
+          partitionType: "RANGE",
+          toPartitions: [{ name: "p1a", value: "50" }],
+        },
+        mockContext,
+      )) as { exists: boolean; table: string };
+
+      expect(result.exists).toBe(false);
+      expect(result.table).toBe("nonexistent");
+    });
   });
 
   describe("mysql_partition_info existence check", () => {
@@ -477,11 +565,13 @@ describe("Partitioning Handler Execution", () => {
 
   describe("mysql_add_partition error handling", () => {
     it("should return structured error for non-partitioned table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error(
-          "Partition management on a not partitioned table is not possible",
-        ),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "users" }]))
+        .mockRejectedValueOnce(
+          new Error(
+            "Partition management on a not partitioned table is not possible",
+          ),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       const result = (await tool.handler(
@@ -499,9 +589,11 @@ describe("Partitioning Handler Execution", () => {
     });
 
     it("should return structured error for MAXVALUE conflict", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error("MAXVALUE can only be used in last partition definition"),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockRejectedValueOnce(
+          new Error("MAXVALUE can only be used in last partition definition"),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       const result = (await tool.handler(
@@ -520,9 +612,15 @@ describe("Partitioning Handler Execution", () => {
     });
 
     it("should return structured error for duplicate partition values", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error("Multiple definition of same constant in list partitioning"),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ TABLE_NAME: "regions" }]),
+        )
+        .mockRejectedValueOnce(
+          new Error(
+            "Multiple definition of same constant in list partitioning",
+          ),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_add_partition")!;
       const result = (await tool.handler(
@@ -542,11 +640,13 @@ describe("Partitioning Handler Execution", () => {
 
   describe("mysql_drop_partition error handling", () => {
     it("should return structured error for non-partitioned table", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error(
-          "Partition management on a not partitioned table is not possible",
-        ),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "users" }]))
+        .mockRejectedValueOnce(
+          new Error(
+            "Partition management on a not partitioned table is not possible",
+          ),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_drop_partition")!;
       const result = (await tool.handler(
@@ -559,9 +659,11 @@ describe("Partitioning Handler Execution", () => {
     });
 
     it("should return structured error for nonexistent partition", async () => {
-      mockAdapter.executeQuery.mockRejectedValue(
-        new Error("Error in list of partitions to DROP"),
-      );
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([{ TABLE_NAME: "logs" }]))
+        .mockRejectedValueOnce(
+          new Error("Error in list of partitions to DROP"),
+        );
 
       const tool = tools.find((t) => t.name === "mysql_drop_partition")!;
       const result = (await tool.handler(