@alternative-path/x-mcp 1.0.0

package/dist/tools/testcase-tools.js

@@ -0,0 +1,762 @@
+export class TestCaseTools {
+    apiClient;
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    getTools() {
+        return [
+            {
+                name: "list_test_cases",
+                description: "List test cases. Can filter by module, search by title, or get all test cases in the project.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        moduleId: {
+                            type: "string",
+                            description: "Optional module ID to filter test cases by module, or 'all' for all modules (default: 'all')",
+                        },
+                        search: {
+                            type: "string",
+                            description: "Optional search term to filter by test case title",
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number for pagination (default: 1)",
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (default: 25)",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_test_case",
+                description: "Get detailed information about a specific test case by ID",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to retrieve",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "get_execution_history",
+                description: "Get execution history for a test case (runs, results, dates).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID (UUID) of the test case to get execution history for",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number for pagination (default: 1)",
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (default: 25)",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "get_execution_plan",
+                description: "Get the exact details of the automated test steps (execution plan) for a test case. Returns the saved plan including steps, tool calls, assertions, and metadata. Use when you need the full automation script/plan for a test case (e.g. NLP-automated test).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID (UUID) of the test case to get the execution plan for",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "create_test_case",
+                description: "Create a new test case in a specified module, component, or subcomponent",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: {
+                            type: "string",
+                            description: "Title/summary of the test case (required)",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Detailed description of the test case",
+                        },
+                        moduleId: {
+                            type: "string",
+                            description: "ID of the module/component/subcomponent where the test case will be created (required)",
+                        },
+                        type: {
+                            type: "string",
+                            description: "Type of test case (e.g., 'Functional Test', 'Regression Test', 'Smoke Test')",
+                        },
+                        status: {
+                            type: "string",
+                            description: "Status of the test case (e.g., 'New', 'In Progress', 'Completed')",
+                        },
+                        priority: {
+                            type: "string",
+                            description: "Priority of the test case (e.g., 'Low', 'Normal', 'High', 'Critical')",
+                        },
+                        estimatedDuration: {
+                            type: "number",
+                            description: "Estimated duration in minutes",
+                        },
+                        testData: {
+                            type: "string",
+                            description: "Test data as JSON string",
+                        },
+                        labels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of label names to attach to the test case",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["title", "moduleId"],
+                },
+            },
+            {
+                name: "update_test_case",
+                description: "Update an existing test case. You can update any field of the test case.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to update (required)",
+                        },
+                        title: {
+                            type: "string",
+                            description: "New title for the test case",
+                        },
+                        description: {
+                            type: "string",
+                            description: "New description for the test case",
+                        },
+                        type: {
+                            type: "string",
+                            description: "New type for the test case",
+                        },
+                        status: {
+                            type: "string",
+                            description: "New status for the test case",
+                        },
+                        priority: {
+                            type: "string",
+                            description: "New priority for the test case",
+                        },
+                        estimatedDuration: {
+                            type: "number",
+                            description: "New estimated duration in minutes",
+                        },
+                        testData: {
+                            type: "string",
+                            description: "New test data as JSON string",
+                        },
+                        labels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "New array of label names",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "delete_test_case",
+                description: "Delete a test case by ID. This action cannot be undone.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to delete (required)",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "clone_test_case",
+                description: "Clone one or more test cases to a target module. Can clone a single test case or multiple test cases at once.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to clone (use this for single clone)",
+                        },
+                        testCaseIds: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of test case IDs to clone (use this for bulk clone)",
+                        },
+                        targetModuleId: {
+                            type: "string",
+                            description: "ID of the target module/component/subcomponent where the cloned test case(s) will be created (required)",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["targetModuleId"],
+                },
+            },
+            {
+                name: "move_test_case",
+                description: "Move a test case from one module to another module, component, or subcomponent",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to move (required)",
+                        },
+                        targetModuleId: {
+                            type: "string",
+                            description: "ID of the target module/component/subcomponent where the test case will be moved (required)",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCaseId", "targetModuleId"],
+                },
+            },
+            {
+                name: "bulk_create_test_cases",
+                description: "Create multiple test cases at once. Useful for importing or creating many test cases efficiently.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCases: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    title: { type: "string" },
+                                    description: { type: "string" },
+                                    moduleId: { type: "string" },
+                                    type: { type: "string" },
+                                    status: { type: "string" },
+                                    priority: { type: "string" },
+                                    estimatedDuration: { type: "number" },
+                                    testData: { type: "string" },
+                                },
+                                required: ["title", "moduleId"],
+                            },
+                            description: "Array of test case objects to create",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID. If not provided, uses the configured project ID.",
+                        },
+                    },
+                    required: ["testCases"],
+                },
+            },
+        ];
+    }
+    handles(name) {
+        return [
+            "list_test_cases",
+            "get_test_case",
+            "get_execution_history",
+            "get_execution_plan",
+            "create_test_case",
+            "update_test_case",
+            "delete_test_case",
+            "clone_test_case",
+            "move_test_case",
+            "bulk_create_test_cases",
+        ].includes(name);
+    }
+    async handle(name, args) {
+        switch (name) {
+            case "list_test_cases":
+                return await this.listTestCases(args);
+            case "get_test_case":
+                return await this.getTestCase(args);
+            case "get_execution_history":
+                return await this.getExecutionHistory(args);
+            case "get_execution_plan":
+                return await this.getExecutionPlan(args);
+            case "create_test_case":
+                return await this.createTestCase(args);
+            case "update_test_case":
+                return await this.updateTestCase(args);
+            case "delete_test_case":
+                return await this.deleteTestCase(args);
+            case "clone_test_case":
+                return await this.cloneTestCase(args);
+            case "move_test_case":
+                return await this.moveTestCase(args);
+            case "bulk_create_test_cases":
+                return await this.bulkCreateTestCases(args);
+            default:
+                throw new Error(`Unknown test case tool: ${name}`);
+        }
+    }
+    async listTestCases(args) {
+        const { moduleId, search, page = 1, pageSize = 25, projectId: argProjectId, } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        const params = {
+            page,
+            pageSize,
+        };
+        // moduleId can be "all" or a UUID, default to "all" if not provided
+        params.moduleId = moduleId || "all";
+        if (search)
+            params.search = search;
+        const response = await this.apiClient.get(`${projectId}/testcase/testcaselist`, { params });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getTestCase(args) {
+        const { testCaseId, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        const response = await this.apiClient.get(`${projectId}/testcase/${testCaseId}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getExecutionHistory(args) {
+        const { testCaseId, projectId: argProjectId, page = 1, pageSize = 25, } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        const response = await this.apiClient.get(`${projectId}/testcase/fetchExecutionHistory/${testCaseId}`, {
+            params: { page, pageSize },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getExecutionPlan(args) {
+        const { testCaseId, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        try {
+            const response = await this.apiClient.get(`${projectId}/auto-execution/execution-records/${testCaseId}`);
+            const record = response?.data ?? null;
+            const plan = record?.plan ?? null;
+            const stepsCount = Array.isArray(plan?.steps) ? plan.steps.length : 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: response?.success ?? true,
+                            message: record
+                                ? stepsCount > 0
+                                    ? "Execution plan fetched successfully."
+                                    : "Execution record exists but has no steps."
+                                : "No automation plan saved for this test case.",
+                            data: {
+                                executionRecordId: record?.id,
+                                testCaseId: record?.testcase_id ?? testCaseId,
+                                plan: plan ?? null,
+                                stepsCount,
+                                created_at: record?.created_at,
+                                updated_at: record?.updated_at,
+                                created_by: record?.created_by,
+                                updated_by: record?.updated_by,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const notFound = err?.message?.includes("not found") ||
+                err?.response?.status === 404;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            message: notFound
+                                ? "No automation plan saved for this test case."
+                                : err?.message ?? "Failed to fetch execution plan.",
+                            data: {
+                                testCaseId,
+                                plan: null,
+                                stepsCount: 0,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async createTestCase(args) {
+        const { title, description, moduleId, type, status, priority, estimatedDuration, testData, labels, projectId: argProjectId, } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!title) {
+            throw new Error("Test case title is required");
+        }
+        if (!moduleId) {
+            throw new Error("Module ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        // Get user ID for generated_by and updated_by (required by backend)
+        const userId = this.apiClient.getUserId();
+        if (!userId) {
+            throw new Error("User ID not available. Please login first.");
+        }
+        const testCaseData = {
+            title: title.trim(),
+            module_id: moduleId,
+            description: description || "", // Default to empty string
+            type: type || "Functional Test", // Default type
+            status: status || "New", // Default status per OpenAPI spec
+            priority: priority || "Normal", // Default priority
+            generated_by: userId, // Required by database model
+            updated_by: userId, // Required by database model
+        };
+        if (estimatedDuration !== undefined) {
+            testCaseData.estimated_duration = estimatedDuration;
+        }
+        else {
+            testCaseData.estimated_duration = 15; // Default duration
+        }
+        if (testData) {
+            try {
+                testCaseData.testdata = typeof testData === "string" ? JSON.parse(testData) : testData;
+            }
+            catch {
+                testCaseData.testdata = testData;
+            }
+        }
+        if (labels && Array.isArray(labels)) {
+            // Transform label names to label objects
+            testCaseData.labels = labels.map((label) => {
+                if (typeof label === "string") {
+                    return { name: label };
+                }
+                return label;
+            });
+        }
+        try {
+            const response = await this.apiClient.post(`${projectId}/testcase/create`, testCaseData);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: response.success,
+                            message: response.message,
+                            data: response.data,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // Provide more detailed error information
+            const errorMessage = error.message || "Error creating test case";
+            throw new Error(`Failed to create test case: ${errorMessage}`);
+        }
+    }
+    async updateTestCase(args) {
+        const { testCaseId, title, description, type, status, priority, estimatedDuration, testData, labels, projectId: argProjectId, } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        // Fetch current test case to preserve existing values for fields not being updated
+        // The backend assigns all fields directly, so we need to include existing values
+        let currentTestCase = null;
+        try {
+            const response = await this.apiClient.get(`${projectId}/testcase/${testCaseId}`);
+            currentTestCase = response.data;
+        }
+        catch (error) {
+            // If we can't fetch the current test case, continue without it
+            // The backend will handle missing fields
+        }
+        const updateData = {};
+        // Only include fields that are being updated
+        if (title !== undefined)
+            updateData.title = title;
+        if (description !== undefined)
+            updateData.description = description || "";
+        if (type !== undefined)
+            updateData.type = type;
+        if (status !== undefined)
+            updateData.status = status;
+        if (priority !== undefined)
+            updateData.priority = priority;
+        if (estimatedDuration !== undefined)
+            updateData.estimated_duration = estimatedDuration;
+        if (testData !== undefined) {
+            try {
+                updateData.testdata =
+                    typeof testData === "string" ? JSON.parse(testData) : testData;
+            }
+            catch {
+                updateData.testdata = testData;
+            }
+        }
+        if (labels !== undefined) {
+            // Transform label names to label objects
+            updateData.labels = labels.map((label) => {
+                if (typeof label === "string") {
+                    return { name: label };
+                }
+                return label;
+            });
+        }
+        if (Object.keys(updateData).length === 0) {
+            throw new Error("At least one field must be provided to update");
+        }
+        // Add updated_by field from the logged-in user (required by backend)
+        const userId = this.apiClient.getUserId();
+        if (!userId) {
+            throw new Error("User ID not available. Please login first.");
+        }
+        updateData.updated_by = userId;
+        const response = await this.apiClient.put(`${projectId}/testcase/${testCaseId}`, updateData);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async deleteTestCase(args) {
+        const { testCaseId, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        // Backend expects ids as an array in the request body
+        const response = await this.apiClient.delete(`${projectId}/testcase/delete`, {
+            data: { ids: [testCaseId] },
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async cloneTestCase(args) {
+        const { testCaseId, testCaseIds, targetModuleId, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!targetModuleId) {
+            throw new Error("Target module ID is required");
+        }
+        if (!testCaseId && (!testCaseIds || testCaseIds.length === 0)) {
+            throw new Error("Either testCaseId or testCaseIds array is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        const cloneData = {
+            targetModuleId,
+        };
+        if (testCaseId) {
+            cloneData.testCaseId = testCaseId;
+        }
+        if (testCaseIds) {
+            cloneData.testCaseIds = testCaseIds;
+        }
+        const response = await this.apiClient.post(`${projectId}/testcase/clone`, cloneData);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async moveTestCase(args) {
+        const { testCaseId, targetModuleId, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!targetModuleId) {
+            throw new Error("Target module ID is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        const response = await this.apiClient.post(`${projectId}/testcase/move`, {
+            testCaseId,
+            targetModuleId,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async bulkCreateTestCases(args) {
+        const { testCases, projectId: argProjectId } = args;
+        const projectId = argProjectId || this.apiClient["projectId"];
+        if (!testCases || !Array.isArray(testCases) || testCases.length === 0) {
+            throw new Error("testCases array is required and must not be empty");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set X_MCP_PROJECT_ID.");
+        }
+        // Transform the test cases to match the API format
+        // Backend expects "Module" (capital M) for bulk create validation
+        const transformedTestCases = testCases.map((tc) => ({
+            title: tc.title,
+            description: tc.description || "",
+            Module: tc.moduleId, // Backend validation expects "Module" (capital M)
+            type: tc.type || "Functional Test",
+            status: tc.status || "New",
+            priority: tc.priority || "Normal",
+            estimated_duration: tc.estimatedDuration || 15,
+            testdata: tc.testData
+                ? typeof tc.testData === "string"
+                    ? JSON.parse(tc.testData)
+                    : tc.testData
+                : null,
+        }));
+        const response = await this.apiClient.post(`${projectId}/testcase/bulkcreate`, {
+            testCases: transformedTestCases,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=testcase-tools.js.map