@skyramp/mcp 0.0.56 → 0.0.58

package/build/services/TestHealthService.test.js

@@ -0,0 +1,211 @@
+import { TestHealthService } from "./TestHealthService.js";
+describe("TestHealthService", () => {
+    let service;
+    beforeEach(() => {
+        service = new TestHealthService();
+    });
+    describe("identifyIssues - endpoint rename detection", () => {
+        function identifyIssues(execution, drift) {
+            return service["identifyIssues"](execution, drift);
+        }
+        it("should create an endpoints_renamed issue when drift has endpoint_renamed changes", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 30,
+                changes: [
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                        details: "Path changed from /api/v1/products to /api/v1/items",
+                    },
+                ],
+                affectedFiles: { files: ["src/routers/product.py"] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeDefined();
+            expect(renameIssue?.severity).toBe("high");
+            expect(renameIssue?.description).toContain("1 API endpoint(s) renamed");
+        });
+        it("should not create endpoints_renamed issue when no renames in drift", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 15,
+                changes: [
+                    {
+                        type: "endpoint_removed",
+                        file: "API Schema",
+                        description: "1 endpoint(s) removed",
+                        severity: "high",
+                    },
+                ],
+                affectedFiles: { files: [] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeUndefined();
+            const removeIssue = issues.find((i) => i.type === "endpoints_removed");
+            expect(removeIssue).toBeDefined();
+        });
+        it("should handle multiple rename changes", () => {
+            const drift = {
+                testFile: "products_smoke_test.py",
+                lastCommit: "abc123",
+                currentCommit: "def456",
+                driftScore: 40,
+                changes: [
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                    },
+                    {
+                        type: "endpoint_renamed",
+                        file: "API Schema",
+                        description: "Endpoint renamed: post /api/v1/products -> /api/v1/items",
+                        severity: "high",
+                    },
+                ],
+                affectedFiles: { files: [] },
+                analysisTimestamp: new Date().toISOString(),
+            };
+            const issues = identifyIssues(undefined, drift);
+            const renameIssue = issues.find((i) => i.type === "endpoints_renamed");
+            expect(renameIssue).toBeDefined();
+            expect(renameIssue?.description).toContain("2 API endpoint(s) renamed");
+        });
+    });
+    describe("generateRecommendation - endpoint rename handling", () => {
+        function generateRecommendation(testFile, driftScore, execution, issues, apiEndpoint, apiSchemaChanges) {
+            const healthScore = service["calculateHealthScore"](execution
+                ? service["calculateExecutionScore"](execution).score
+                : undefined, driftScore);
+            return service["generateRecommendation"](testFile, healthScore, driftScore, execution, issues, apiEndpoint, apiSchemaChanges);
+        }
+        it("should return UPDATE action for endpoint renames regardless of drift score", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            // Even with low drift score, renames should trigger UPDATE
+            const rec = generateRecommendation("products_smoke_test.py", 12, // low drift
+            undefined, issues, undefined, apiSchemaChanges);
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.priority).toBe("HIGH");
+            expect(rec.rationale).toContain("renamed");
+            expect(rec.estimatedWork).toBe("SMALL");
+        });
+        it("should include renamedEndpoints in recommendation details", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 30, undefined, issues, undefined, apiSchemaChanges);
+            expect(rec.details?.endpointStatus).toBe("renamed");
+            expect(rec.details?.renamedEndpoints).toBeDefined();
+            expect(rec.details?.renamedEndpoints).toHaveLength(1);
+            expect(rec.details?.renamedEndpoints?.[0]).toEqual({
+                oldPath: "/api/v1/products",
+                newPath: "/api/v1/items",
+                method: "get",
+            });
+        });
+        it("should mention test failure in rationale when test is failing due to rename", () => {
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "1 API endpoint(s) renamed",
+                    details: "Endpoint renamed: get /api/v1/products -> /api/v1/items",
+                },
+            ];
+            const execution = {
+                testFile: "products_smoke_test.py",
+                executedAt: new Date().toISOString(),
+                passed: false,
+                duration: 10000,
+                errors: ["404 Not Found"],
+                warnings: [],
+                crashed: false,
+            };
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 30, execution, issues, undefined, apiSchemaChanges);
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.rationale).toContain("failing");
+        });
+        it("should not set renamedEndpoints when there are no renames", () => {
+            const rec = generateRecommendation("orders_smoke_test.py", 5, undefined, [], { exists: true }, undefined);
+            expect(rec.action).toBe("VERIFY");
+            expect(rec.details?.renamedEndpoints).toBeUndefined();
+            expect(rec.details?.endpointStatus).toBe("exists");
+        });
+        it("should prefer rename handling over high-drift REGENERATE", () => {
+            // If drift is > 70 but it's caused by a rename, we should UPDATE not REGENERATE
+            const issues = [
+                {
+                    type: "endpoints_renamed",
+                    severity: "high",
+                    description: "5 API endpoint(s) renamed",
+                    details: "Multiple renames",
+                },
+            ];
+            const apiSchemaChanges = {
+                endpointsRemoved: [],
+                endpointsRenamed: [
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+                    { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "post" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "get" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "put" },
+                    { oldPath: "/api/v1/products/{id}", newPath: "/api/v1/items/{id}", method: "delete" },
+                ],
+                endpointsModified: [],
+                authenticationChanged: false,
+            };
+            const rec = generateRecommendation("products_smoke_test.py", 75, // would normally trigger REGENERATE
+            undefined, issues, undefined, apiSchemaChanges);
+            // Rename detection should take priority over drift threshold
+            expect(rec.action).toBe("UPDATE");
+            expect(rec.estimatedWork).toBe("SMALL"); // renames are simple substitutions
+        });
+    });
+});

package/build/tools/submitReportTool.js

@@ -4,6 +4,7 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { AnalyticsService } from "../services/AnalyticsService.js";
 const TOOL_NAME = "skyramp_submit_report";
+const DEFAULT_COMMIT_MESSAGE = "Added recommendations by Skyramp Testbot.";
 const testResultSchema = z.object({
     testType: z.string().describe("Type of test: Smoke, Contract, Integration, Fuzz, E2E, Load, etc."),
     endpoint: z.string().describe("HTTP verb and path, e.g. 'GET /api/v1/products'"),
@@ -41,6 +42,12 @@ export function registerSubmitReportTool(server) {
             issuesFound: z
                 .array(descriptionSchema)
                 .describe("List of issues, failures, or bugs found. Use empty array [] if none."),
+            commitMessage: z
+                .string()
+                .optional()
+                .default(DEFAULT_COMMIT_MESSAGE)
+                .describe("Succinct commit message (under 72 chars) summarizing what the testbot did, " +
+                "e.g. 'add contract tests for /products endpoint' or 'update smoke tests for order API changes'"),
         },
         _meta: {
             keywords: ["report", "summary", "testbot", "submit"],
@@ -54,6 +61,7 @@ export function registerSubmitReportTool(server) {
             testMaintenance: params.testMaintenance,
             testResults: params.testResults,
             issuesFound: params.issuesFound,
+            commitMessage: (params.commitMessage ?? "").replace(/[\r\n]+/g, " ").trim().slice(0, 72) || DEFAULT_COMMIT_MESSAGE,
         }, null, 2);
         logger.info("Submitting testbot report", {
             outputFile: params.summaryOutputFile,
@@ -88,10 +96,11 @@ export function registerSubmitReportTool(server) {
             return errorResult;
         }
         finally {
-            const recordParams = {
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
                 summary_output_file: params.summaryOutputFile,
-            };
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, recordParams);
+                testResultCount: String(params.testResults.length),
+                payloadBytes: String(reportJson.length),
+            }).catch(() => { });
         }
     });
 }

package/build/tools/submitReportTool.test.js

@@ -7,7 +7,7 @@ jest.mock("../utils/logger.js", () => ({
     logger: { info: jest.fn(), error: jest.fn() },
 }));
 jest.mock("../services/AnalyticsService.js", () => ({
-    AnalyticsService: { pushMCPToolEvent: jest.fn() },
+    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
 }));
 function captureToolHandler() {
     let handler;
@@ -104,6 +104,64 @@ describe("registerSubmitReportTool", () => {
         expect(result.isError).toBe(true);
         expect(result.content[0].text).toContain("Failed to write report");
     });
+    it("should write commitMessage when provided", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const result = await handler({
+            ...sampleReportParams(outputFile),
+            commitMessage: "add contract tests for /products endpoint",
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe("add contract tests for /products endpoint");
+    });
+    it("should use default commitMessage when omitted", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const result = await handler(sampleReportParams(outputFile));
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
+    });
+    it("should sanitize commitMessage (newlines, length)", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const result = await handler({
+            ...sampleReportParams(outputFile),
+            commitMessage: "  line one\nline two\r\nline three  ",
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe("line one line two line three");
+        expect(written.commitMessage.length).toBeLessThanOrEqual(72);
+    });
+    it("should use default commitMessage when provided as empty string", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const result = await handler({
+            ...sampleReportParams(outputFile),
+            commitMessage: "",
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
+    });
+    it("should use default commitMessage when whitespace-only", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+        tmpDirs.push(tmpDir);
+        const outputFile = path.join(tmpDir, "report.json");
+        const result = await handler({
+            ...sampleReportParams(outputFile),
+            commitMessage: "   \n\r\n   ",
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
+        expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
+    });
     it("should produce valid JSON with pretty formatting", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
         tmpDirs.push(tmpDir);

package/build/tools/test-maintenance/actionsTool.js

@@ -2,7 +2,60 @@ import { z } from "zod";
 import { logger } from "../../utils/logger.js";
 import { StateManager, } from "../../utils/AnalysisStateManager.js";
 import * as fs from "fs";
+import * as path from "path";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
+/**
+ * Compute a suggested new filename when an endpoint is renamed.
+ *
+ * Extracts the differing static segments between oldPath and newPath,
+ * then replaces occurrences in the filename.
+ *
+ * Example:
+ *   testFile:  "/repo/tests/python/products_smoke_test.py"
+ *   oldPath:   "/api/v1/products"
+ *   newPath:   "/api/v1/items"
+ *   result:    "/repo/tests/python/items_smoke_test.py"
+ */
+export function computeRenamedTestFile(testFile, renames) {
+    const basename = path.basename(testFile);
+    let newBasename = basename;
+    for (const rename of renames) {
+        const oldSegments = rename.oldPath.split("/").filter((s) => s.length > 0);
+        const newSegments = rename.newPath.split("/").filter((s) => s.length > 0);
+        if (oldSegments.length !== newSegments.length)
+            continue;
+        const paramPattern = /^\{[^}]+\}$/;
+        for (let i = 0; i < oldSegments.length; i++) {
+            if (paramPattern.test(oldSegments[i]))
+                continue;
+            if (oldSegments[i] !== newSegments[i]) {
+                // Replace the old segment name in the filename with the new one
+                // Handle both exact matches and common variations:
+                //   "products" in "products_smoke_test.py"
+                //   "product" in "product_smoke_test.py" (singular)
+                const oldName = oldSegments[i].toLowerCase();
+                const newName = newSegments[i].toLowerCase();
+                if (newBasename.toLowerCase().includes(oldName)) {
+                    // Case-preserving replace
+                    const idx = newBasename.toLowerCase().indexOf(oldName);
+                    newBasename =
+                        newBasename.substring(0, idx) +
+                            newName +
+                            newBasename.substring(idx + oldName.length);
+                }
+            }
+        }
+    }
+    if (newBasename === basename)
+        return null; // No change needed
+    const newFilePath = path.join(path.dirname(testFile), newBasename);
+    // Don't suggest a rename if the target file already exists
+    if (fs.existsSync(newFilePath)) {
+        logger.info(`Skipping file rename suggestion: ${newFilePath} already exists`);
+        return null;
+    }
+    return newFilePath;
+}
 const actionsSchema = {
     stateFile: z
         .string()
@@ -70,6 +123,7 @@ Comprehensive report with executed actions, summary, and detailed analysis
                         rationale: test.recommendation.rationale,
                         estimatedWork: test.recommendation.estimatedWork,
                         issues: test.issues || [],
+                        renamedEndpoints: test.recommendation.details?.renamedEndpoints || [],
                     });
                 }
             });
@@ -130,11 +184,33 @@ Comprehensive report with executed actions, summary, and detailed analysis
                     logger.error(`Failed to read test file ${rec.testFile}: ${error.message}`);
                     continue;
                 }
+                // Check if this is a rename-driven update
+                const renames = rec.renamedEndpoints || [];
+                const isRenameUpdate = renames.length > 0;
                 // Build update instructions
                 let instruction = `\n### ${rec.testFile}\n\n`;
                 instruction += `**Priority:** ${rec.priority} | `;
                 instruction += `**Estimated Effort:** ${rec.estimatedWork || "Small"}\n\n`;
                 instruction += `**Why Update Needed:** ${rec.rationale}\n\n`;
+                if (isRenameUpdate) {
+                    instruction += `**🔄 Endpoint Rename Detected — Path Substitution Required:**\n\n`;
+                    instruction += `| Old Path | New Path | Method |\n`;
+                    instruction += `|----------|----------|--------|\n`;
+                    for (const rename of renames) {
+                        instruction += `| \`${rename.oldPath}\` | \`${rename.newPath}\` | ${rename.method} |\n`;
+                    }
+                    instruction += `\n`;
+                    instruction += `**Action:** Find-and-replace all occurrences of the old path with the new path in this test file. `;
+                    instruction += `Do NOT change any test logic, assertions, or structure — only update the URL paths.\n\n`;
+                    // Compute suggested file rename
+                    const suggestedNewFile = computeRenamedTestFile(rec.testFile, renames);
+                    if (suggestedNewFile) {
+                        instruction += `**📁 File Rename:** After updating the paths, rename this file:\n`;
+                        instruction += `- From: \`${path.basename(rec.testFile)}\`\n`;
+                        instruction += `- To: \`${path.basename(suggestedNewFile)}\`\n\n`;
+                        rec._suggestedNewFile = suggestedNewFile;
+                    }
+                }
                 if (driftData) {
                     instruction += `**Analysis:**\n`;
                     instruction += `- Drift Score: ${driftData.driftScore ?? "N/A"}\n`;
@@ -184,16 +260,46 @@ Comprehensive report with executed actions, summary, and detailed analysis
             responseText += `4. Show you the changes made\n\n`;
             responseText += `5. At the end of the tool execution, MUST display the below message\n`;
             responseText += `**This tool is currently in Early Preview stage. Please verify the results.**\n\n`;
+            // Collect all rename mappings across recommendations
+            const allRenames = [];
+            for (const rec of updateRecommendations) {
+                if (rec.renamedEndpoints && rec.renamedEndpoints.length > 0) {
+                    allRenames.push(...rec.renamedEndpoints);
+                }
+            }
+            // Deduplicate renames
+            const uniqueRenames = allRenames.filter((r, i, arr) => arr.findIndex((x) => x.oldPath === r.oldPath &&
+                x.newPath === r.newPath &&
+                x.method === r.method) === i);
             // Build LLM-only instructions (hidden from users)
-            const llmInstructions = `<!-- LLM_INSTRUCTIONS:
-{
-  "workflow": "test_maintenance",
-  "action": "execute_updates",
-  "auto_proceed": true,
-  "files_to_update": ${JSON.stringify(testFilesToUpdate)},
-  "update_count": ${updateRecommendations.length}
-}
--->\n`;
+            const llmInstructionsObj = {
+                workflow: "test_maintenance",
+                action: "execute_updates",
+                auto_proceed: true,
+                files_to_update: testFilesToUpdate,
+                update_count: updateRecommendations.length,
+            };
+            if (uniqueRenames.length > 0) {
+                llmInstructionsObj.endpoint_renames = uniqueRenames;
+                llmInstructionsObj.rename_strategy =
+                    "For each file, find-and-replace all occurrences of oldPath with newPath. Do NOT regenerate or restructure the test — only update the URL paths.";
+                // Collect file rename suggestions
+                const fileRenames = [];
+                for (const rec of updateRecommendations) {
+                    if (rec._suggestedNewFile) {
+                        fileRenames.push({
+                            from: rec.testFile,
+                            to: rec._suggestedNewFile,
+                        });
+                    }
+                }
+                if (fileRenames.length > 0) {
+                    llmInstructionsObj.file_renames = fileRenames;
+                    llmInstructionsObj.file_rename_strategy =
+                        "After updating path content in each file, rename the file using 'mv' or equivalent. Use git mv if the repo tracks the file.";
+                }
+            }
+            const llmInstructions = `<!-- LLM_INSTRUCTIONS:\n${JSON.stringify(llmInstructionsObj, null, 2)}\n-->\n`;
             return {
                 content: [
                     {

package/build/tools/test-maintenance/actionsTool.test.js

@@ -0,0 +1,93 @@
+// Mock modules that use ESM-only features (import.meta) before importing actionsTool
+jest.mock("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn() },
+}));
+jest.mock("../../utils/logger.js", () => ({
+    logger: { info: jest.fn(), warning: jest.fn(), error: jest.fn(), debug: jest.fn() },
+}));
+jest.mock("../../utils/AnalysisStateManager.js", () => ({
+    StateManager: { fromStatePath: jest.fn() },
+}));
+jest.mock("fs");
+// @ts-ignore
+import { computeRenamedTestFile } from "./actionsTool.js";
+import * as fs from "fs";
+const mockExistsSync = fs.existsSync;
+describe("computeRenamedTestFile", () => {
+    beforeEach(() => {
+        // Default: target file does not exist
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    // --- Basic renames ---
+    it("should rename products_smoke_test.py to items_smoke_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_smoke_test.py");
+    });
+    it("should rename products_contract_test.py to items_contract_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_contract_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_contract_test.py");
+    });
+    it("should rename products_integration_test.py to items_integration_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_integration_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "post" }]);
+        expect(result).toBe("/repo/tests/python/items_integration_test.py");
+    });
+    it("should rename products_fuzz_test.py to items_fuzz_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_fuzz_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_fuzz_test.py");
+    });
+    it("should rename products_load_test.py to items_load_test.py", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_load_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/python/items_load_test.py");
+    });
+    // --- Different file extensions ---
+    it("should work with .ts test files", () => {
+        const result = computeRenamedTestFile("/repo/tests/products.test.ts", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/items.test.ts");
+    });
+    it("should work with .js test files", () => {
+        const result = computeRenamedTestFile("/repo/tests/products_smoke.test.js", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/repo/tests/items_smoke.test.js");
+    });
+    // --- Returns null when no rename needed ---
+    it("should return null when filename does not contain old segment", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/orders_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBeNull();
+    });
+    it("should return null when target file already exists", () => {
+        mockExistsSync.mockReturnValue(true);
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBeNull();
+    });
+    it("should return null when segments have different lengths", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v2/catalog/items", method: "get" }]);
+        // Different segment counts — no substitution attempted
+        expect(result).toBeNull();
+    });
+    it("should return null with empty renames array", () => {
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", []);
+        expect(result).toBeNull();
+    });
+    // --- Multiple renames ---
+    it("should apply multiple rename mappings", () => {
+        // Unlikely but possible: two segments change
+        const result = computeRenamedTestFile("/repo/tests/python/products_smoke_test.py", [
+            { oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" },
+            { oldPath: "/api/v1/products/{product_id}", newPath: "/api/v1/items/{item_id}", method: "get" },
+        ]);
+        expect(result).toBe("/repo/tests/python/items_smoke_test.py");
+    });
+    // --- Preserves directory structure ---
+    it("should preserve the directory path", () => {
+        const result = computeRenamedTestFile("/home/runner/work/api-insight/api-insight/tests/python/products_smoke_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v1/items", method: "get" }]);
+        expect(result).toBe("/home/runner/work/api-insight/api-insight/tests/python/items_smoke_test.py");
+    });
+    // --- Version bump rename ---
+    it("should handle version segment rename in filename if present", () => {
+        const result = computeRenamedTestFile("/repo/tests/v1_products_test.py", [{ oldPath: "/api/v1/products", newPath: "/api/v2/products", method: "get" }]);
+        // "v1" in filename gets replaced with "v2"
+        expect(result).toBe("/repo/tests/v2_products_test.py");
+    });
+});