postgresai 0.15.0-dev.1 → 0.15.0-dev.11

package/test/mcp-server.test.ts

@@ -75,6 +75,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -92,6 +93,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -121,6 +123,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "config-api-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -151,6 +154,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -186,6 +190,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -214,6 +219,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -242,6 +248,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -259,6 +266,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -276,6 +284,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -306,6 +315,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -347,6 +357,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -366,6 +377,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -376,7 +388,8 @@ describe("MCP Server", () => {
       );
 
       expect(response.isError).toBe(true);
-      expect(getResponseText(response)).toBe("content is required");
+      // Error message updated to reflect that attachments alone are also valid input.
+      expect(getResponseText(response)).toBe("content or attachments is required");
 
       readConfigSpy.mockRestore();
     });
@@ -385,6 +398,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -419,6 +433,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -457,6 +472,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
         projectName: null,
@@ -474,6 +490,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
         projectName: null,
@@ -491,6 +508,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -508,6 +526,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 42,
         defaultProject: null,
         projectName: null,
@@ -537,6 +556,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
         projectName: null,
@@ -572,6 +592,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -616,6 +637,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -635,6 +657,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -652,6 +675,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -671,6 +695,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -690,6 +715,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -726,6 +752,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -753,6 +780,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -785,6 +813,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -817,6 +846,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -851,6 +881,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -870,6 +901,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -880,7 +912,7 @@ describe("MCP Server", () => {
       );
 
       expect(response.isError).toBe(true);
-      expect(getResponseText(response)).toBe("content is required");
+      expect(getResponseText(response)).toBe("content or attachments is required");
 
       readConfigSpy.mockRestore();
     });
@@ -889,6 +921,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -923,6 +956,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -957,6 +991,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -974,6 +1009,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -991,6 +1027,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1008,6 +1045,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1025,6 +1063,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1063,6 +1102,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1098,6 +1138,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1133,6 +1174,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1150,6 +1192,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1172,6 +1215,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1202,6 +1246,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1221,6 +1266,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1240,6 +1286,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1276,6 +1323,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1318,6 +1366,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1356,6 +1405,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1375,6 +1425,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1394,6 +1445,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1413,6 +1465,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1446,6 +1499,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1478,6 +1532,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1517,6 +1572,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
         projectName: null,
@@ -1531,11 +1587,414 @@ describe("MCP Server", () => {
     });
   });
 
+  describe("list_reports tool", () => {
+    test("successfully returns reports list as JSON", async () => {
+      const mockReports = [
+        { id: 1, org_id: 1, org_name: "TestOrg", project_id: 10, project_name: "prod-db", status: "completed" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockReports), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports"));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].status).toBe("completed");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes filters to API", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("list_reports", {
+        project_id: 5,
+        status: "completed",
+        limit: 10,
+      }));
+
+      expect(capturedUrl).toContain("project_id=eq.5");
+      expect(capturedUrl).toContain("status=eq.completed");
+      expect(capturedUrl).toContain("limit=10");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("handles API errors gracefully", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response('{"message": "Unauthorized"}', {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports"));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("401");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes before_date to API as created_at filter", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("list_reports", {
+        before_date: "2025-01-15",
+      }));
+
+      expect(capturedUrl).toContain("created_at=lt.2025-01-15");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("fetches all reports when all=true", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const mockReports = [
+        { id: 10, org_id: 1, org_name: "O", project_id: 1, project_name: "P", status: "completed" },
+      ];
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockReports), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports", {
+        all: true,
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].id).toBe(10);
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
+  describe("list_report_files tool", () => {
+    test("returns error when neither report_id nor check_id is provided", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const response = await handleToolCall(createRequest("list_report_files", {}));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("Either report_id or check_id is required");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("works with only check_id (no report_id)", async () => {
+      const mockFiles = [
+        { id: 100, checkup_report_id: 1, filename: "H002.md", check_id: "H002", type: "md" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockFiles), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_report_files", {
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].filename).toBe("H002.md");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+      expect(capturedUrl).not.toContain("checkup_report_id");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("successfully returns report files", async () => {
+      const mockFiles = [
+        { id: 100, checkup_report_id: 1, filename: "H002.md", check_id: "H002", type: "md" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockFiles), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_report_files", {
+        report_id: 1,
+        type: "md",
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].filename).toBe("H002.md");
+      expect(capturedUrl).toContain("checkup_report_id=eq.1");
+      expect(capturedUrl).toContain("type=eq.md");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
+  describe("get_report_data tool", () => {
+    test("returns error when neither report_id nor check_id is provided", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const response = await handleToolCall(createRequest("get_report_data", {}));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("Either report_id or check_id is required");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("works with only check_id (no report_id)", async () => {
+      const mockData = [
+        {
+          id: 100,
+          checkup_report_id: 1,
+          filename: "H002.md",
+          check_id: "H002",
+          type: "md",
+          data: "# H002\n\nUnused indexes found.",
+        },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("get_report_data", {
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].data).toContain("# H002");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+      expect(capturedUrl).not.toContain("checkup_report_id");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("successfully returns report data with content", async () => {
+      const mockData = [
+        {
+          id: 100,
+          checkup_report_id: 1,
+          filename: "H002.md",
+          check_id: "H002",
+          type: "md",
+          data: "# H002\n\nUnused indexes found.",
+        },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("get_report_data", {
+        report_id: 1,
+        type: "md",
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].data).toContain("# H002");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes filters to API", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("get_report_data", {
+        report_id: 42,
+        type: "json",
+        check_id: "F004",
+      }));
+
+      expect(capturedUrl).toContain("checkup_report_id=eq.42");
+      expect(capturedUrl).toContain("type=eq.json");
+      expect(capturedUrl).toContain("check_id=eq.F004");
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
   describe("error propagation", () => {
     test("propagates API errors through MCP layer", async () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
         projectName: null,
@@ -1564,6 +2023,7 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
         projectName: null,
@@ -1581,4 +2041,486 @@ describe("MCP Server", () => {
       readConfigSpy.mockRestore();
     });
   });
+
+  describe("attachments parameter & file tools", () => {
+    // Real-file approach (rather than fs mocking) — ESM module caching means
+    // monkey-patching fs after `import * as fs from "fs"` does not affect the
+    // already-resolved binding inside storage.ts. Real tmp files are simpler
+    // and match how the existing storage tests work.
+    const fs = require("fs") as typeof import("fs");
+    const path = require("path") as typeof import("path");
+    const os = require("os") as typeof import("os");
+
+    const createdDirs: string[] = [];
+
+    function mockTinyFile(name: string, body = "FAKE"): string {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pgai-mcp-attach-"));
+      createdDirs.push(dir);
+      const p = path.join(dir, name);
+      fs.writeFileSync(p, body);
+      return p;
+    }
+
+    afterEach(() => {
+      while (createdDirs.length > 0) {
+        const d = createdDirs.pop();
+        if (d) fs.rmSync(d, { recursive: true, force: true });
+      }
+    });
+
+    function configWithKey() {
+      return spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: 1,
+        defaultProject: null,
+        projectName: null,
+      });
+    }
+
+    test("upload_file tool returns url + ready-to-paste markdown link", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("shot.png");
+
+      globalThis.fetch = mock((_url: string, _init?: RequestInit) =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              success: true,
+              url: "/files/9/abc.png",
+              metadata: { originalName: "shot.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r1",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          )
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("upload_file", { path: fakePath }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+
+      expect(response.isError).toBeFalsy();
+      const obj = JSON.parse(getResponseText(response));
+      expect(obj.success).toBe(true);
+      expect(obj.url).toBe("/files/9/abc.png");
+      // Image extension renders inline.
+      expect(obj.markdown).toBe("![shot.png](https://storage.example.com/files/9/abc.png)");
+
+      cfgSpy.mockRestore();
+    });
+
+    test("upload_file requires path", async () => {
+      const cfgSpy = configWithKey();
+      const r = await handleToolCall(createRequest("upload_file", {}));
+      expect(r.isError).toBe(true);
+      expect(getResponseText(r)).toBe("path is required");
+      cfgSpy.mockRestore();
+    });
+
+    test("download_file tool requires url", async () => {
+      const cfgSpy = configWithKey();
+      const r = await handleToolCall(createRequest("download_file", {}));
+      expect(r.isError).toBe(true);
+      expect(getResponseText(r)).toBe("url is required");
+      cfgSpy.mockRestore();
+    });
+
+    test("post_issue_comment with attachments uploads and appends link", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("debug.png");
+
+      const calls: Array<{ url: string; method?: string; bodyJson?: unknown }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        calls.push({
+          url: u,
+          method: init?.method,
+          bodyJson: typeof init?.body === "string" ? JSON.parse(init.body as string) : undefined,
+        });
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true,
+              url: "/files/9/dbg.png",
+              metadata: { originalName: "debug.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r1",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_comment_create")) {
+          return new Response(
+            JSON.stringify({
+              id: "c1",
+              issue_id: "i1",
+              author_id: 1,
+              parent_comment_id: null,
+              content: "ignored",
+              created_at: "",
+              updated_at: "",
+              data: null,
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("post_issue_comment", {
+          issue_id: "11111111-1111-1111-1111-111111111111",
+          content: "see screenshot",
+          attachments: [fakePath],
+        }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+
+      expect(response.isError).toBeFalsy();
+
+      // Upload happened first, then comment-create with augmented content.
+      expect(calls[0].url).toContain("/upload");
+      const commentCall = calls.find((c) => c.url.endsWith("/rpc/issue_comment_create"));
+      expect(commentCall).toBeTruthy();
+      const body = commentCall!.bodyJson as { content: string };
+      expect(body.content).toBe("see screenshot\n\n![debug.png](https://storage.example.com/files/9/dbg.png)");
+
+      cfgSpy.mockRestore();
+    });
+
+    test("post_issue_comment with only attachments (no content) is allowed", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("only.png");
+
+      const commentBodies: Array<{ content: string }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true,
+              url: "/files/9/only.png",
+              metadata: { originalName: "only.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_comment_create")) {
+          commentBodies.push(JSON.parse(String(init?.body)));
+          return new Response(
+            JSON.stringify({ id: "c1", issue_id: "i1", author_id: 1, parent_comment_id: null, content: "", created_at: "", updated_at: "", data: null }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("post_issue_comment", {
+          issue_id: "11111111-1111-1111-1111-111111111111",
+          content: "",
+          attachments: [fakePath],
+        }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+
+      expect(response.isError).toBeFalsy();
+      expect(commentBodies[0].content).toBe("![only.png](https://storage.example.com/files/9/only.png)");
+
+      cfgSpy.mockRestore();
+    });
+
+    test("post_issue_comment with no content and no attachments is rejected", async () => {
+      const cfgSpy = configWithKey();
+      const r = await handleToolCall(
+        createRequest("post_issue_comment", {
+          issue_id: "11111111-1111-1111-1111-111111111111",
+          content: "",
+        })
+      );
+      expect(r.isError).toBe(true);
+      expect(getResponseText(r)).toBe("content or attachments is required");
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue with attachments and no description fetches existing then appends", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("evidence.png");
+
+      const calls: Array<{ url: string; method?: string; body?: unknown }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        calls.push({
+          url: u,
+          method: init?.method,
+          body: typeof init?.body === "string" ? JSON.parse(init.body as string) : undefined,
+        });
+        if (u.includes("/issues?") && (init?.method ?? "GET") === "GET") {
+          return new Response(
+            JSON.stringify([
+              { id: "i1", title: "T", description: "Existing description", status: 0, created_at: "", action_items: [] },
+            ]),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true,
+              url: "/files/9/ev.png",
+              metadata: { originalName: "evidence.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_update")) {
+          return new Response(
+            JSON.stringify({ id: "i1", title: "T", description: "ignored", status: 0, updated_at: "" }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("update_issue", {
+          issue_id: "i1",
+          attachments: [fakePath],
+        }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+
+      expect(response.isError).toBeFalsy();
+      const updateCall = calls.find((c) => c.url.endsWith("/rpc/issue_update"));
+      expect(updateCall).toBeTruthy();
+      // Order: GET issues -> POST upload -> POST update.
+      const fetchIdx = calls.findIndex((c) => c.url.includes("/issues?"));
+      const uploadIdx = calls.findIndex((c) => c.url.endsWith("/upload"));
+      const updateIdx = calls.findIndex((c) => c.url.endsWith("/rpc/issue_update"));
+      expect(fetchIdx).toBeGreaterThanOrEqual(0);
+      expect(uploadIdx).toBeGreaterThan(fetchIdx);
+      expect(updateIdx).toBeGreaterThan(uploadIdx);
+
+      const body = updateCall!.body as { p_description: string };
+      expect(body.p_description).toBe(
+        "Existing description\n\n![evidence.png](https://storage.example.com/files/9/ev.png)"
+      );
+
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue with only attachments is treated as a valid update", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("ok.png");
+
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.includes("/issues?")) {
+          return new Response(JSON.stringify([{ id: "i1", title: "T", description: "old", status: 0 }]), {
+            status: 200, headers: { "Content-Type": "application/json" },
+          });
+        }
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true, url: "/files/9/ok.png",
+              metadata: { originalName: "ok.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_update")) {
+          return new Response(JSON.stringify({ id: "i1", title: "T", description: "ignored", status: 0, updated_at: "" }), {
+            status: 200, headers: { "Content-Type": "application/json" },
+          });
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("update_issue", { issue_id: "i1", attachments: [fakePath] }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+      expect(response.isError).toBeFalsy();
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue with no fields including no attachments is rejected", async () => {
+      const cfgSpy = configWithKey();
+      const r = await handleToolCall(createRequest("update_issue", { issue_id: "i1" }));
+      expect(r.isError).toBe(true);
+      expect(getResponseText(r)).toContain("At least one field to update is required");
+      // The error message now mentions attachments as a valid update field.
+      expect(getResponseText(r)).toContain("attachments");
+      cfgSpy.mockRestore();
+    });
+
+    test("create_issue with attachments appends link to provided description", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("design.png");
+
+      const createBodies: Array<{ description?: string }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true, url: "/files/9/dz.png",
+              metadata: { originalName: "design.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_create")) {
+          createBodies.push(JSON.parse(String(init?.body)));
+          return new Response(
+            JSON.stringify({ id: "i1", title: "T", description: "ignored", created_at: "", status: 0 }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("create_issue", {
+          title: "Dx",
+          description: "see design",
+          attachments: [fakePath],
+        }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+      expect(response.isError).toBeFalsy();
+      expect(createBodies[0].description).toBe(
+        "see design\n\n![design.png](https://storage.example.com/files/9/dz.png)"
+      );
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue_comment with attachments appends to content", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("after.png");
+
+      const bodies: Array<{ p_content?: string }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true, url: "/files/9/aft.png",
+              metadata: { originalName: "after.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_comment_update")) {
+          bodies.push(JSON.parse(String(init?.body)));
+          return new Response(JSON.stringify({ id: "c1", issue_id: "i1", content: "ignored", updated_at: "" }), {
+            status: 200, headers: { "Content-Type": "application/json" },
+          });
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("update_issue_comment", { comment_id: "c1", content: "now updated", attachments: [fakePath] }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+      expect(response.isError).toBeFalsy();
+      expect(bodies[0].p_content).toBe("now updated\n\n![after.png](https://storage.example.com/files/9/aft.png)");
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue_comment with attachments-only (no content) sends just the markdown link", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("only.png");
+
+      const bodies: Array<{ p_content?: string }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true, url: "/files/9/only.png",
+              metadata: { originalName: "only.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_comment_update")) {
+          bodies.push(JSON.parse(String(init?.body)));
+          return new Response(JSON.stringify({ id: "c1", issue_id: "i1", content: "ignored", updated_at: "" }), {
+            status: 200, headers: { "Content-Type": "application/json" },
+          });
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("update_issue_comment", { comment_id: "c1", attachments: [fakePath] }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+      expect(response.isError).toBeFalsy();
+      expect(bodies).toHaveLength(1);
+      expect(bodies[0].p_content).toBe("![only.png](https://storage.example.com/files/9/only.png)");
+      cfgSpy.mockRestore();
+    });
+
+    test("update_issue_comment without content and without attachments is rejected", async () => {
+      const cfgSpy = configWithKey();
+      const fetchSpy = mock(() => {
+        throw new Error("should not be called");
+      });
+      globalThis.fetch = fetchSpy as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("update_issue_comment", { comment_id: "c1" }));
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toBe("content or attachments is required");
+      expect(fetchSpy).not.toHaveBeenCalled();
+      cfgSpy.mockRestore();
+    });
+
+    test("create_issue with attachments and no description sets description to just the link", async () => {
+      const cfgSpy = configWithKey();
+      const fakePath = mockTinyFile("plan.png");
+
+      const createBodies: Array<{ description?: string }> = [];
+      globalThis.fetch = mock(async (url: string | URL, init?: RequestInit) => {
+        const u = String(url);
+        if (u.endsWith("/upload")) {
+          return new Response(
+            JSON.stringify({
+              success: true, url: "/files/9/plan.png",
+              metadata: { originalName: "plan.png", size: 4, mimeType: "image/png", uploadedAt: "", duration: 0 },
+              requestId: "r",
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        if (u.endsWith("/rpc/issue_create")) {
+          createBodies.push(JSON.parse(String(init?.body)));
+          return new Response(
+            JSON.stringify({ id: "i1", title: "T", description: "ignored", created_at: "", status: 0 }),
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        return new Response("nope", { status: 404 });
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(
+        createRequest("create_issue", { title: "Dx", attachments: [fakePath] }),
+        { apiBaseUrl: "https://api.example.com", storageBaseUrl: "https://storage.example.com" }
+      );
+      expect(response.isError).toBeFalsy();
+      expect(createBodies[0].description).toBe("![plan.png](https://storage.example.com/files/9/plan.png)");
+      cfgSpy.mockRestore();
+    });
+  });
 });