@alternative-path/qa-path-mcp 1.0.0

package/dist/__tests__/tools/project-tools.test.js

@@ -0,0 +1,674 @@
+import { ProjectTools } from "../../tools/project-tools.js";
+import { mapApiErrorToMcpResponse, mapApiResponseToMcpError } from "../../utils/mcp-error-mapper.js";
+// Mock the error mapper
+jest.mock("../../utils/mcp-error-mapper.js", () => ({
+    mapApiErrorToMcpResponse: jest.fn(),
+    mapApiResponseToMcpError: jest.fn(),
+}));
+describe("ProjectTools", () => {
+    let projectTools;
+    let mockApiClient;
+    beforeEach(() => {
+        mockApiClient = {
+            get: jest.fn(),
+            post: jest.fn(),
+            put: jest.fn(),
+        };
+        projectTools = new ProjectTools(mockApiClient);
+        jest.clearAllMocks();
+    });
+    describe("listProjects", () => {
+        it("should return projects on success", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Projects retrieved successfully",
+                data: [
+                    { id: "1", name: "Project 1", prefix: "P1" },
+                    { id: "2", name: "Project 2", prefix: "P2" },
+                ],
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/getProjects", { page: 1, pageSize: 25 });
+            expect(result).toHaveProperty("content");
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+            expect(parsed.data).toHaveLength(2);
+        });
+        it("should validate required page parameter", async () => {
+            const result = await projectTools.handle("list_projects", {
+                pageSize: 25,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PAGE");
+        });
+        it("should validate page is >= 1", async () => {
+            const result = await projectTools.handle("list_projects", {
+                page: 0,
+                pageSize: 25,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PAGE");
+        });
+        it("should validate required pageSize parameter", async () => {
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PAGE_SIZE");
+        });
+        it("should validate pageSize is between 1 and 10000", async () => {
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 10001,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PAGE_SIZE");
+        });
+        it("should validate sortField against allowed values", async () => {
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                sortField: "invalid_field",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_SORT_FIELD");
+        });
+        it("should accept valid sortField values", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Success",
+                data: [],
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                sortField: "name",
+                sortOrder: "ASC",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/getProjects", {
+                page: 1,
+                pageSize: 25,
+                sortField: "name",
+                sortOrder: "ASC",
+            });
+        });
+        it("should handle API failure response", async () => {
+            const mockResponse = {
+                success: false,
+                message: "Failed to retrieve",
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("LIST_FAILED");
+        });
+        it("should throw on infrastructure errors", async () => {
+            mockApiClient.post.mockRejectedValue(new Error("Network error"));
+            await expect(projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+            })).rejects.toThrow("Network error");
+        });
+        it("should include query parameter if provided", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Success",
+                data: [],
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                query: "name contains 'API'",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/getProjects", {
+                page: 1,
+                pageSize: 25,
+                query: "name contains 'API'",
+            });
+        });
+        it("should trim query parameter before sending", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Success",
+                data: [],
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                query: "  name contains 'API'  ",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/getProjects", {
+                page: 1,
+                pageSize: 25,
+                query: "name contains 'API'",
+            });
+        });
+        it("should not include query if empty string", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Success",
+                data: [],
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                query: "   ",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/getProjects", {
+                page: 1,
+                pageSize: 25,
+            });
+        });
+        it("should validate query length does not exceed 5000 characters", async () => {
+            const longQuery = "a".repeat(5001);
+            const result = await projectTools.handle("list_projects", {
+                page: 1,
+                pageSize: 25,
+                query: longQuery,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_QUERY");
+        });
+    });
+    describe("createProject", () => {
+        it("should validate required name field", async () => {
+            const result = await projectTools.handle("create_project", {
+                prefix: "PRJ",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_NAME");
+        });
+        it("should validate name is non-empty string", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: "",
+                prefix: "PRJ",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_NAME");
+        });
+        it("should validate name is string type", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: 123,
+                prefix: "PRJ",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_NAME");
+        });
+        it("should validate required prefix field", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PREFIX");
+        });
+        it("should validate prefix is non-empty string", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "",
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PREFIX");
+        });
+        it("should validate description type if provided", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+                description: 123,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_DESCRIPTION_TYPE");
+        });
+        it("should validate context type if provided", async () => {
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+                context: true,
+            });
+            expect(mockApiClient.post).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_CONTEXT_TYPE");
+        });
+        it("should trim string fields before sending", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Project created",
+                data: { id: "123", name: "Test Project", prefix: "PRJ" },
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue(null);
+            await projectTools.handle("create_project", {
+                name: "  Test Project  ",
+                prefix: "  PRJ  ",
+                description: "  Description  ",
+                context: "  Context  ",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/createProject", {
+                name: "Test Project",
+                prefix: "PRJ",
+                description: "Description",
+                context: "Context",
+            });
+        });
+        it("should create project successfully", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Project created successfully",
+                data: {
+                    id: "123",
+                    name: "Test Project",
+                    prefix: "PRJ",
+                },
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue(null);
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe("Project created successfully");
+            expect(parsed.data.id).toBe("123");
+        });
+        it("should handle API business failure", async () => {
+            const mockResponse = {
+                success: false,
+                message: "Project name already exists",
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error_code: "CREATE_FAILED",
+                            message: "Project name already exists",
+                        }),
+                    },
+                ],
+            });
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("CREATE_FAILED");
+        });
+        it("should handle API validation error (4xx)", async () => {
+            const mockError = {
+                response: {
+                    status: 400,
+                    data: { message: "Invalid request data" },
+                },
+            };
+            mockApiClient.post.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error_code: "BAD_REQUEST",
+                            message: "Invalid request data",
+                        }),
+                    },
+                ],
+            });
+            const result = await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("BAD_REQUEST");
+        });
+        it("should throw on infrastructure errors (5xx)", async () => {
+            const mockError = new Error("Server error");
+            mockError.response = { status: 500, data: {} };
+            mockApiClient.post.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            await expect(projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+            })).rejects.toThrow("Server error");
+        });
+        it("should not include optional fields if not provided", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Project created",
+                data: { id: "123", name: "Test", prefix: "PRJ" },
+            };
+            mockApiClient.post.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue(null);
+            await projectTools.handle("create_project", {
+                name: "Test Project",
+                prefix: "PRJ",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/project/createProject", {
+                name: "Test Project",
+                prefix: "PRJ",
+            });
+        });
+    });
+    describe("updateProject", () => {
+        it("should validate required projectId field", async () => {
+            const result = await projectTools.handle("update_project", {
+                name: "Updated Name",
+            });
+            expect(mockApiClient.put).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PROJECT_ID");
+        });
+        it("should validate projectId is string", async () => {
+            const result = await projectTools.handle("update_project", {
+                projectId: 123,
+                name: "Updated Name",
+            });
+            expect(mockApiClient.put).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PROJECT_ID");
+        });
+        it("should validate required name field", async () => {
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+            });
+            expect(mockApiClient.put).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_NAME");
+        });
+        it("should validate name is non-empty string", async () => {
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "",
+            });
+            expect(mockApiClient.put).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_NAME");
+        });
+        it("should validate description type if provided", async () => {
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+                description: 123,
+            });
+            expect(mockApiClient.put).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_DESCRIPTION_TYPE");
+        });
+        it("should validate context type if provided", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Project updated successfully",
+                data: {
+                    id: "123",
+                    name: "Updated Name",
+                    prefix: "PRJ",
+                },
+            };
+            mockApiClient.put.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue(null);
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+                context: null,
+            });
+            // null should be allowed (optional field) - should not be included in body
+            expect(mockApiClient.put).toHaveBeenCalledWith("/project/update", {
+                id: "123",
+                name: "Updated Name",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+        });
+        it("should update project successfully", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Project updated successfully",
+                data: {
+                    id: "123",
+                    name: "Updated Name",
+                    prefix: "PRJ",
+                },
+            };
+            mockApiClient.put.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue(null);
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+            });
+            expect(mockApiClient.put).toHaveBeenCalledWith("/project/update", {
+                id: "123",
+                name: "Updated Name",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe("Project updated successfully");
+        });
+        it("should handle API business failure", async () => {
+            const mockResponse = {
+                success: false,
+                message: "Project name already exists",
+            };
+            mockApiClient.put.mockResolvedValue(mockResponse);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            mapApiResponseToMcpError.mockReturnValue({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error_code: "UPDATE_FAILED",
+                            message: "Project name already exists",
+                        }),
+                    },
+                ],
+            });
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("UPDATE_FAILED");
+        });
+        it("should handle API validation error (4xx)", async () => {
+            const mockError = {
+                response: {
+                    status: 404,
+                    data: { message: "Project not found" },
+                },
+            };
+            mockApiClient.put.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error_code: "NOT_FOUND",
+                            message: "Project not found",
+                        }),
+                    },
+                ],
+            });
+            const result = await projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("NOT_FOUND");
+        });
+        it("should throw on infrastructure errors (5xx)", async () => {
+            const mockError = new Error("Server error");
+            mockError.response = { status: 500, data: {} };
+            mockApiClient.put.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            await expect(projectTools.handle("update_project", {
+                projectId: "123",
+                name: "Updated Name",
+            })).rejects.toThrow("Server error");
+        });
+    });
+    describe("suggestProjectPrefix", () => {
+        it("should validate required projectName field", async () => {
+            const result = await projectTools.handle("suggest_project_prefix", {});
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PROJECT_NAME");
+        });
+        it("should validate projectName is non-empty string", async () => {
+            const result = await projectTools.handle("suggest_project_prefix", {
+                projectName: "",
+            });
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PROJECT_NAME");
+        });
+        it("should validate projectName is string type", async () => {
+            const result = await projectTools.handle("suggest_project_prefix", {
+                projectName: 123,
+            });
+            expect(mockApiClient.get).not.toHaveBeenCalled();
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("INVALID_PROJECT_NAME");
+        });
+        it("should trim projectName before sending", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Key is available",
+                data: "TP",
+            };
+            mockApiClient.get.mockResolvedValue(mockResponse);
+            await projectTools.handle("suggest_project_prefix", {
+                projectName: "  Test Project  ",
+            });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/project/generateUniquePrefixForProject", { params: { projectName: "Test Project" } });
+        });
+        it("should return prefix suggestion on success", async () => {
+            const mockResponse = {
+                success: true,
+                message: "Key is available",
+                data: "TP",
+            };
+            mockApiClient.get.mockResolvedValue(mockResponse);
+            const result = await projectTools.handle("suggest_project_prefix", {
+                projectName: "Test Project",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(true);
+            expect(parsed.message).toBe("Key is available");
+            expect(parsed.data.prefix).toBe("TP");
+            expect(parsed.data.projectName).toBe("Test Project");
+        });
+        it("should handle API failure response", async () => {
+            const mockResponse = {
+                success: false,
+                message: "Failed to generate prefix",
+            };
+            mockApiClient.get.mockResolvedValue(mockResponse);
+            const result = await projectTools.handle("suggest_project_prefix", {
+                projectName: "Test Project",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("PREFIX_GENERATION_FAILED");
+            expect(parsed.message).toBe("Failed to generate prefix");
+        });
+        it("should handle API validation error (4xx)", async () => {
+            const mockError = {
+                response: {
+                    status: 400,
+                    data: { message: "Project name is required" },
+                },
+            };
+            mockApiClient.get.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error_code: "BAD_REQUEST",
+                            message: "Project name is required",
+                        }),
+                    },
+                ],
+            });
+            const result = await projectTools.handle("suggest_project_prefix", {
+                projectName: "Test Project",
+            });
+            const parsed = JSON.parse(result.content[0].text);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error_code).toBe("BAD_REQUEST");
+        });
+        it("should throw on infrastructure errors (5xx)", async () => {
+            const mockError = new Error("Server error");
+            mockError.response = { status: 500, data: {} };
+            mockApiClient.get.mockRejectedValue(mockError);
+            mapApiErrorToMcpResponse.mockReturnValue(null);
+            await expect(projectTools.handle("suggest_project_prefix", {
+                projectName: "Test Project",
+            })).rejects.toThrow("Server error");
+        });
+    });
+    describe("handle", () => {
+        it("should throw error for unknown tool", async () => {
+            await expect(projectTools.handle("unknown_tool", {})).rejects.toThrow("Unknown project tool: unknown_tool");
+        });
+    });
+});
+//# sourceMappingURL=project-tools.test.js.map