@skyramp/mcp 0.1.2 → 0.1.4

package/build/utils/scenarioDrafting.test.js

@@ -1,529 +1,306 @@
-// @ts-ignore
-import { isRealResource, draftScenariosFromEndpoints, draftDiffDirectScenarios, inferResourceRelationships, } from "./scenarioDrafting.js";
-describe("isRealResource", () => {
-    it("accepts normal resource names", () => {
-        expect(isRealResource("users")).toBe(true);
-        expect(isRealResource("products")).toBe(true);
-        expect(isRealResource("orders")).toBe(true);
-    });
-    it("accepts hyphenated resource names (not action verbs)", () => {
-        expect(isRealResource("saved-searches")).toBe(true);
-        expect(isRealResource("order-items")).toBe(true);
-        expect(isRealResource("user-profiles")).toBe(true);
-        expect(isRealResource("api-keys")).toBe(true);
-    });
-    it("rejects action-like single words", () => {
-        expect(isRealResource("login")).toBe(false);
-        expect(isRealResource("logout")).toBe(false);
-        expect(isRealResource("verify")).toBe(false);
-        expect(isRealResource("health")).toBe(false);
-        expect(isRealResource("ping")).toBe(false);
-        expect(isRealResource("dashboard")).toBe(false);
-        expect(isRealResource("webhook")).toBe(false);
-    });
-    it("rejects action-verb-hyphenated patterns", () => {
-        expect(isRealResource("forgot-password")).toBe(false);
-        expect(isRealResource("reset-password")).toBe(false);
-        expect(isRealResource("verify-email")).toBe(false);
-        expect(isRealResource("confirm-order")).toBe(false);
-        expect(isRealResource("send-notification")).toBe(false);
-        expect(isRealResource("create-session")).toBe(false);
-        expect(isRealResource("delete-cache")).toBe(false);
-    });
-    it("is case-insensitive", () => {
-        expect(isRealResource("Login")).toBe(false);
-        expect(isRealResource("VERIFY")).toBe(false);
-        expect(isRealResource("Forgot-Password")).toBe(false);
-    });
-});
-describe("draftScenariosFromEndpoints — irregular plural singularization", () => {
-    it("uses 'category' (not 'categorie') in FK field names for -ies plurals", () => {
-        const endpoints = [
-            { path: "/api/categories", methods: [{ method: "GET" }, { method: "POST" }] },
-            { path: "/api/categories/{id}", methods: [{ method: "GET" }, { method: "PUT" }, { method: "DELETE" }] },
-            { path: "/api/items", methods: [{ method: "GET" }, { method: "POST" }] },
-            { path: "/api/items/{id}", methods: [{ method: "GET" }, { method: "DELETE" }] },
-        ];
-        const scenarios = draftScenariosFromEndpoints(endpoints, [{ method: "POST", path: "/api/categories" }]);
-        const allText = JSON.stringify(scenarios);
-        expect(allText).not.toContain("categorie_id");
-        expect(allText).not.toContain("\"categorie\"");
-        // The diff-direct integration scenario description should use "category" (singular)
-        const integrationScenario = scenarios.find((s) => s.scenarioName === "categories-post-lifecycle");
-        expect(integrationScenario).toBeDefined();
-        expect(integrationScenario.steps[0].description).toContain("category");
-    });
-    it("uses 'status' (not 'statu') in FK field names for -ses plurals", () => {
-        const endpoints = [
-            { path: "/api/statuses", methods: [{ method: "GET" }, { method: "POST" }] },
-            { path: "/api/statuses/{id}", methods: [{ method: "GET" }, { method: "DELETE" }] },
-        ];
-        const scenarios = draftScenariosFromEndpoints(endpoints, [{ method: "POST", path: "/api/statuses" }]);
-        const allText = JSON.stringify(scenarios);
-        expect(allText).not.toContain("statu_id");
-        // The diff-direct integration scenario description should use "status" (singular)
-        const integrationScenario = scenarios.find((s) => s.scenarioName === "statuses-post-lifecycle");
-        expect(integrationScenario).toBeDefined();
-        expect(integrationScenario.steps[0].description).toContain("status");
-    });
-});
-describe("draftScenariosFromEndpoints", () => {
-    it("returns empty array for no endpoints", () => {
-        expect(draftScenariosFromEndpoints([])).toEqual([]);
-    });
-});
-describe("inferResourceRelationships", () => {
-    it("returns empty map for endpoints with no nesting or FK fields", () => {
-        const endpoints = [
-            { path: "/api/users", methods: [{ method: "GET" }] },
-            { path: "/api/products", methods: [{ method: "GET" }] },
-        ];
-        expect(inferResourceRelationships(endpoints).size).toBe(0);
-    });
-    it("detects parent→child relationship from path nesting (/parent/{id}/child)", () => {
-        const endpoints = [
-            { path: "/api/collections/{id}/links", methods: [{ method: "GET" }] },
-        ];
-        const rel = inferResourceRelationships(endpoints);
-        expect(rel.has("links")).toBe(true);
-        expect(rel.get("links").has("collections")).toBe(true);
-    });
-    it("detects FK relationship from request body field ({resource}_id)", () => {
-        const endpoints = [
-            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { product_id: "abc" } } }] }] },
-            { path: "/api/products", methods: [{ method: "GET" }] },
-        ];
-        const rel = inferResourceRelationships(endpoints);
-        expect(rel.has("orders")).toBe(true);
-        expect(rel.get("orders").has("products")).toBe(true);
-    });
-    it("does not create self-reference", () => {
-        const endpoints = [
-            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { order_id: "abc" } } }] }] },
-        ];
-        const rel = inferResourceRelationships(endpoints);
-        // orders should not reference itself
-        expect(rel.get("orders")?.has("orders")).toBeFalsy();
-    });
-    it("ignores FK fields that point to unknown resources", () => {
-        const endpoints = [
-            { path: "/api/orders", methods: [{ method: "POST", interactions: [{ request: { body: { nonexistent_resource_id: "abc" } } }] }] },
-        ];
-        const rel = inferResourceRelationships(endpoints);
-        // nonexistent_resource is not a known endpoint resource, should be ignored
-        expect(rel.get("orders")?.size ?? 0).toBe(0);
-    });
-});
-describe("draftDiffDirectScenarios", () => {
+import { draftScenariosFromEndpoints, draftMinimalScenarios, } from "./scenarioDrafting.js";
+// ---------------------------------------------------------------------------
+// draftMinimalScenarios
+// ---------------------------------------------------------------------------
+describe("draftMinimalScenarios", () => {
     const makeGroups = (defs) => new Map(Object.entries(defs).map(([k, v]) => [k, { ...v, methods: new Set(v.methods) }]));
-    it("returns empty array when newEndpoints is empty", () => {
+    it("returns empty array when endpoints is empty", () => {
         const groups = makeGroups({ orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" } });
-        expect(draftDiffDirectScenarios([], groups)).toEqual([]);
+        expect(draftMinimalScenarios([], groups, "new_endpoint")).toEqual([]);
     });
-    it("generates new_endpoint-category scenarios for a new PUT endpoint", () => {
+    it("GET endpoint → 1 contract scenario only (no integration)", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT"], paramPath: "/api/orders/{order_id}" },
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups);
-        // PUT generates: mutation-recalc, contract, not-found (3 scenarios)
-        // Note: we intentionally skip the redundant "happy-path" integration for PUT/PATCH
-        // because mutation-recalc already provides comprehensive happy-path coverage
-        expect(scenarios.length).toBeGreaterThanOrEqual(3);
-        const newEndpointScenarios = scenarios.filter(s => s.category === "new_endpoint");
-        expect(newEndpointScenarios.length).toBeGreaterThanOrEqual(2);
-        // Mutation-recalculation scenario is drafted first for PUT/PATCH
-        const mutationRecalc = scenarios.find(s => s.testType === "integration" && s.scenarioName.includes("mutation-verify"));
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.steps.some(st => st.method === "PUT")).toBe(true);
-        expect(mutationRecalc.description).toContain("Mutation test");
-        // Note: happy-path integration removed for PUT/PATCH - mutation-recalc covers this
-        // Contract test
-        const contract = scenarios.find(s => s.testType === "contract" && s.steps[0].expectedStatusCode === 200);
-        expect(contract).toBeDefined();
-        // Not-found edge case
-        const notFound = scenarios.find(s => s.steps.some(st => st.expectedStatusCode === 404));
-        expect(notFound).toBeDefined();
-    });
-    it("generates mutation-recalc scenario for a new PATCH endpoint", () => {
+        const result = draftMinimalScenarios([{ method: "GET", path: "/api/orders/{id}" }], groups, "new_endpoint");
+        expect(result).toHaveLength(1);
+        expect(result[0].testType).toBe("contract");
+        expect(result[0].scenarioName).toBe("orders-by-id-get-new-contract");
+        expect(result[0].steps).toHaveLength(1);
+        expect(result[0].steps[0].expectedStatusCode).toBe(200);
+    });
+    it("POST endpoint → 1 contract + 1 integration", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PATCH"], paramPath: "/api/orders/{order_id}" },
+            products: { basePath: "/api/products", methods: ["GET", "POST"], paramPath: "/api/products/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PATCH", path: "/api/orders/{order_id}" }], groups);
-        // Mutation-recalculation scenario is drafted for PATCH
-        const mutationRecalc = scenarios.find(s => s.scenarioName === "orders-patch-mutation-verify");
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.testType).toBe("integration");
-        expect(mutationRecalc.category).toBe("new_endpoint");
-        expect(mutationRecalc.priority).toBe("high");
-        expect(mutationRecalc.description).toContain("Mutation test");
-        expect(mutationRecalc.description).toContain("derived calculations");
-        // Should have 3 steps: POST (create) → PATCH (add items) → GET (verify)
-        expect(mutationRecalc.steps).toHaveLength(3);
-        expect(mutationRecalc.steps[0].method).toBe("POST");
-        expect(mutationRecalc.steps[1].method).toBe("PATCH");
-        expect(mutationRecalc.steps[2].method).toBe("GET");
-        // Note: happy-path integration removed for PUT/PATCH - mutation-recalc covers this
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/products" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        const contract = result.find(s => s.testType === "contract");
+        const integration = result.find(s => s.testType === "integration");
+        expect(contract).toBeDefined();
+        expect(integration).toBeDefined();
+        expect(contract.scenarioName).toBe("products-post-new-contract");
+        expect(integration.scenarioName).toBe("products-post-new-integration");
     });
-    it("integration scenario minimum steps: POST resource then PUT — LLM discovers prereqs from source code", () => {
+    it("PUT endpoint → 1 contract + 1 integration", () => {
         const groups = makeGroups({
             orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT"], paramPath: "/api/orders/{order_id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups);
-        // Mutation-recalculation scenario comes first
-        const mutationRecalc = scenarios.find(s => s.testType === "integration" && s.scenarioName.includes("mutation-verify"));
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.steps.some(st => st.method === "POST" && st.path === "/api/orders")).toBe(true);
-        expect(mutationRecalc.steps.some(st => st.method === "PUT")).toBe(true);
-        // Note: happy-path integration removed for PUT/PATCH
-        // mutation-recalc already provides comprehensive happy-path coverage with POST → PUT → GET
-        // The minimum steps (POST + PUT) are already verified in the mutationRecalc check above
+        const result = draftMinimalScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        expect(result.find(s => s.testType === "contract")).toBeDefined();
+        expect(result.find(s => s.testType === "integration")).toBeDefined();
+        // Both use the resolved path
+        expect(result[0].steps[0].path).toBe("/api/orders/{order_id}");
+    });
+    it("DELETE endpoint → 1 contract + 1 integration", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST", "DELETE"], paramPath: "/api/orders/{id}" },
+        });
+        const result = draftMinimalScenarios([{ method: "DELETE", path: "/api/orders/{id}" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        const contract = result.find(s => s.testType === "contract");
+        const integration = result.find(s => s.testType === "integration");
+        expect(contract).toBeDefined();
+        expect(integration).toBeDefined();
     });
-    it("generates 3 scenarios for a new POST endpoint", () => {
+    it("each scenario has exactly 1 step", () => {
         const groups = makeGroups({
-            products: { basePath: "/api/products", methods: ["GET", "POST"], paramPath: "/api/products/{id}" },
+            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT", "DELETE"], paramPath: "/api/orders/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/api/products" }], groups);
-        expect(scenarios.length).toBe(3); // integration, contract, validation
-        const types = scenarios.map(s => s.testType);
-        expect(types).toContain("integration");
-        expect(types).toContain("contract");
-        // validation error scenario (422)
-        expect(scenarios.some(s => s.steps.some(st => st.expectedStatusCode === 422))).toBe(true);
+        const result = draftMinimalScenarios([
+            { method: "GET", path: "/api/orders/{id}" },
+            { method: "POST", path: "/api/orders" },
+            { method: "PUT", path: "/api/orders/{id}" },
+            { method: "DELETE", path: "/api/orders/{id}" },
+        ], groups, "new_endpoint");
+        for (const s of result) {
+            expect(s.steps).toHaveLength(1);
+        }
     });
-    it("ignores unknown paths and skips action-verb segments", () => {
+    it("new_endpoint category → scenario names contain 'new'", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["POST", "DELETE"], paramPath: "/api/orders/{id}" },
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/api/health" }], // 'health' is not a real resource
-        groups);
-        expect(scenarios).toEqual([]);
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/orders" }], groups, "new_endpoint");
+        for (const s of result) {
+            expect(s.category).toBe("new_endpoint");
+            expect(s.scenarioName).toContain("-new-");
+        }
     });
-    it("draftScenariosFromEndpoints passes newEndpoints through to diff-direct scenarios", () => {
-        const endpoints = [
-            { path: "/api/orders", methods: ["GET", "POST", "PUT"] },
-            { path: "/api/orders/{order_id}", methods: ["GET", "PUT", "DELETE"] },
-        ];
-        const newEndpoints = [{ method: "PUT", path: "/api/orders/{order_id}" }];
-        const scenarios = draftScenariosFromEndpoints(endpoints, newEndpoints);
-        const diffDirect = scenarios.filter(s => s.category === "new_endpoint");
-        expect(diffDirect.length).toBeGreaterThan(0);
-        expect(diffDirect.some(s => s.steps.some(st => st.method === "PUT"))).toBe(true);
+    it("business_rule category → scenario names contain 'changed'", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
+        });
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/orders" }], groups, "business_rule");
+        for (const s of result) {
+            expect(s.category).toBe("business_rule");
+            expect(s.scenarioName).toContain("-changed-");
+        }
     });
-    it("resolves router-relative param paths (e.g. /{order_id}) against known resourceGroups", () => {
+    it("passes through router-relative param paths as-is (LLM resolves from source)", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/v1/orders", methods: ["GET", "POST", "PATCH", "DELETE"], paramPath: "/api/v1/orders/{order_id}" },
-            products: { basePath: "/api/v1/products", methods: ["GET", "POST"], paramPath: "/api/v1/products/{id}" },
+            orders: { basePath: "/api/v1/orders", methods: ["GET", "POST", "PATCH"], paramPath: "/api/v1/orders/{order_id}" },
         });
-        // Diff scanner reports router-relative path, not the full API path
-        const scenarios = draftDiffDirectScenarios([{ method: "PATCH", path: "/{order_id}" }], groups);
-        expect(scenarios.length).toBeGreaterThanOrEqual(3);
-        // Mutation-recalculation scenario is drafted
-        const mutationRecalc = scenarios.find(s => s.scenarioName === "orders-patch-mutation-verify");
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.testType).toBe("integration");
-        expect(mutationRecalc.category).toBe("new_endpoint");
-        expect(mutationRecalc.steps[1].method).toBe("PATCH");
-        // Contract and not-found scenarios use the resolved full path
-        const contract = scenarios.find(s => s.scenarioName.includes("contract"));
-        expect(contract).toBeDefined();
-        expect(contract.steps[0].path).toBe("/api/v1/orders/{order_id}");
-        const notFound = scenarios.find(s => s.scenarioName.includes("not-found"));
-        expect(notFound).toBeDefined();
-        expect(notFound.steps[0].path).toBe("/api/v1/orders/{order_id}");
+        const result = draftMinimalScenarios([{ method: "PATCH", path: "/{order_id}" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        // Path is passed through as-is — the LLM resolves full path during source enrichment
+        expect(result[0].steps[0].path).toBe("/{order_id}");
     });
     it("resolves router-relative base paths (e.g. /orders) against known resourceGroups", () => {
         const groups = makeGroups({
             orders: { basePath: "/api/v1/orders", methods: ["GET", "POST"], paramPath: "/api/v1/orders/{order_id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/orders" }], groups);
-        expect(scenarios.length).toBeGreaterThanOrEqual(2);
-        const integration = scenarios.find(s => s.testType === "integration");
-        expect(integration).toBeDefined();
-        expect(integration.category).toBe("new_endpoint");
+        const result = draftMinimalScenarios([{ method: "POST", path: "/orders" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        expect(result[0].scenarioName).toContain("orders");
     });
-    it("skips unresolvable router-relative paths", () => {
+    it("generates scenarios for any endpoint path (LLM validates relevance from source)", () => {
         const groups = makeGroups({
             products: { basePath: "/api/v1/products", methods: ["GET", "POST"], paramPath: "/api/v1/products/{id}" },
         });
-        // /{nonexistent_id} doesn't match any known resource
-        const scenarios = draftDiffDirectScenarios([{ method: "PATCH", path: "/{nonexistent_id}" }], groups);
-        expect(scenarios).toEqual([]);
+        // Even unresolvable paths get seed scenarios — the LLM discards irrelevant ones
+        const result = draftMinimalScenarios([{ method: "PATCH", path: "/{nonexistent_id}" }], groups, "new_endpoint");
+        expect(result).toHaveLength(2); // contract + integration
     });
-    it("PR #195 regression: PATCH /{order_id} produces mutation-recalculate scenario in GENERATE slots", () => {
-        // Simulates the exact data from PR #195:
-        // - Full endpoint list with orders, products, reviews
-        // - newEndpoints has PATCH /{order_id} (router-relative)
-        const endpoints = [
-            { path: "/api/v1/orders", methods: ["GET", "POST"] },
-            { path: "/api/v1/orders/{order_id}", methods: ["GET", "PATCH", "DELETE"] },
-            { path: "/api/v1/products", methods: ["GET", "POST"] },
-            { path: "/api/v1/products/{product_id}", methods: ["GET", "PUT", "DELETE"] },
-            { path: "/api/v1/reviews", methods: ["GET", "POST"] },
-            { path: "/api/v1/reset", methods: ["POST"] },
-        ];
-        const newEndpoints = [{ method: "PATCH", path: "/{order_id}" }];
-        const allScenarios = draftScenariosFromEndpoints(endpoints, newEndpoints);
-        // The diff-direct scenarios should include orders-patch-mutation-verify
-        const mutationRecalc = allScenarios.find(s => s.scenarioName === "orders-patch-mutation-verify");
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.category).toBe("new_endpoint"); // → CRITICAL priority tier
-        expect(mutationRecalc.steps).toHaveLength(3);
-        expect(mutationRecalc.steps[0].method).toBe("POST");
-        expect(mutationRecalc.steps[1].method).toBe("PATCH");
-        expect(mutationRecalc.steps[2].method).toBe("GET");
-        expect(mutationRecalc.description).toContain("derived calculations");
-        // Verify it outranks all non-new_endpoint scenarios (cascade-delete, unique-constraint, etc.)
-        const newEndpointScenarios = allScenarios.filter(s => s.category === "new_endpoint");
-        const otherScenarios = allScenarios.filter(s => s.category !== "new_endpoint");
-        expect(newEndpointScenarios.length).toBeGreaterThanOrEqual(3);
-        // All new_endpoint scenarios should include our mutation-recalculate
-        expect(newEndpointScenarios.some(s => s.scenarioName === "orders-patch-mutation-verify")).toBe(true);
-        // Non-new_endpoint scenarios should NOT include mutation-recalculate
-        expect(otherScenarios.every(s => s.scenarioName !== "orders-patch-mutation-verify")).toBe(true);
+    it("deduplicates scenarios by method+path+testType key", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
+        });
+        // Same endpoint twice
+        const result = draftMinimalScenarios([
+            { method: "POST", path: "/api/orders" },
+            { method: "POST", path: "/api/orders" },
+        ], groups, "new_endpoint");
+        expect(result).toHaveLength(2); // 1 contract + 1 integration, not doubled
+    });
+    it("action sub-path falls back to parent resource", () => {
+        const groups = makeGroups({
+            products: { basePath: "/api/v1/products", methods: ["GET", "POST"], paramPath: "/api/v1/products/{id}" },
+        });
+        const result = draftMinimalScenarios([{ method: "GET", path: "/api/v1/products/search" }], groups, "new_endpoint");
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some(s => s.scenarioName.includes("products"))).toBe(true);
+    });
+    it("different paths resolving to same resource both produce scenarios (no silent dedup)", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
+        });
+        // GET /api/orders and GET /api/orders/search both involve "orders" resource
+        const result = draftMinimalScenarios([
+            { method: "GET", path: "/api/orders" },
+            { method: "GET", path: "/api/orders/search" },
+        ], groups, "new_endpoint");
+        // Both should produce contract scenarios (not deduplicated)
+        expect(result).toHaveLength(2);
+        const paths = result.map(s => s.steps[0].path);
+        expect(paths).toContain("/api/orders");
+        expect(paths).toContain("/api/orders/search");
+        // Scenario names should be distinct
+        expect(result[0].scenarioName).not.toBe(result[1].scenarioName);
+    });
+    it("multiple methods on same path → correct scenario count", () => {
+        const groups = makeGroups({
+            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT", "DELETE"], paramPath: "/api/orders/{id}" },
+        });
+        const result = draftMinimalScenarios([
+            { method: "GET", path: "/api/orders/{id}" },
+            { method: "PUT", path: "/api/orders/{id}" },
+            { method: "DELETE", path: "/api/orders/{id}" },
+        ], groups, "new_endpoint");
+        // GET → 1 contract; PUT → 1 contract + 1 integration; DELETE → 1 contract + 1 integration = 5
+        expect(result).toHaveLength(5);
     });
 });
-describe("diffDirectMutationRecalc — diverse app types (no hardcoded field names)", () => {
+// ---------------------------------------------------------------------------
+// extractResourceName — parent-segment fallback (tested indirectly)
+// ---------------------------------------------------------------------------
+describe("resolveEndpoint — prefix matching for sub-paths", () => {
     const makeGroups = (defs) => new Map(Object.entries(defs).map(([k, v]) => [k, { ...v, methods: new Set(v.methods) }]));
-    const testCases = [
-        {
-            name: "E-commerce: PATCH /orders/{order_id}",
-            resource: "orders",
-            group: { basePath: "/api/v1/orders", methods: ["GET", "POST", "PATCH"], paramPath: "/api/v1/orders/{order_id}" },
-            method: "PATCH",
-            expectedParamName: "order_id",
-        },
-        {
-            name: "Project management: PUT /projects/{id}",
-            resource: "projects",
-            group: { basePath: "/api/projects", methods: ["GET", "POST", "PUT"], paramPath: "/api/projects/{id}" },
-            method: "PUT",
-            expectedParamName: "id",
-        },
-        {
-            name: "Invoicing: PATCH /invoices/{invoice_id}",
-            resource: "invoices",
-            group: { basePath: "/v2/invoices", methods: ["GET", "POST", "PATCH"], paramPath: "/v2/invoices/{invoice_id}" },
-            method: "PATCH",
-            expectedParamName: "invoice_id",
-        },
-        {
-            name: "Education LMS: PUT /courses/{course_id}",
-            resource: "courses",
-            group: { basePath: "/api/courses", methods: ["GET", "POST", "PUT"], paramPath: "/api/courses/{course_id}" },
-            method: "PUT",
-            expectedParamName: "course_id",
-        },
-        {
-            name: "Healthcare: PATCH /prescriptions/{prescription_id}",
-            resource: "prescriptions",
-            group: { basePath: "/api/prescriptions", methods: ["GET", "POST", "PATCH"], paramPath: "/api/prescriptions/{prescription_id}" },
-            method: "PATCH",
-            expectedParamName: "prescription_id",
-        },
-        {
-            name: "Logistics: PUT /shipments/{shipment_id}",
-            resource: "shipments",
-            group: { basePath: "/api/shipments", methods: ["GET", "POST", "PUT"], paramPath: "/api/shipments/{shipment_id}" },
-            method: "PUT",
-            expectedParamName: "shipment_id",
-        },
-        {
-            name: "Restaurant: PATCH /menus/{menuId}",
-            resource: "menus",
-            group: { basePath: "/api/menus", methods: ["GET", "POST", "PATCH"], paramPath: "/api/menus/{menuId}" },
-            method: "PATCH",
-            expectedParamName: "menuId",
-        },
-        {
-            name: "Cloud billing: PUT /subscriptions/{subscription_id}",
-            resource: "subscriptions",
-            group: { basePath: "/billing/subscriptions", methods: ["GET", "POST", "PUT"], paramPath: "/billing/subscriptions/{subscription_id}" },
-            method: "PUT",
-            expectedParamName: "subscription_id",
-        },
-        {
-            name: "Warehouse: PATCH /inventories/{uuid}",
-            resource: "inventories",
-            group: { basePath: "/api/inventories", methods: ["GET", "POST", "PATCH"], paramPath: "/api/inventories/{uuid}" },
-            method: "PATCH",
-            expectedParamName: "uuid",
-        },
-        {
-            name: "Minimal: PATCH /items (no paramPath)",
-            resource: "items",
-            group: { basePath: "/items", methods: ["GET", "POST", "PATCH"] },
-            method: "PATCH",
-            expectedParamName: "item_id",
-        },
-    ];
-    it.each(testCases)("$name — produces valid mutation-recalc scenario", ({ resource, group, method, expectedParamName }) => {
-        const groups = makeGroups({ [resource]: group });
-        const scenarios = draftDiffDirectScenarios([{ method, path: group.paramPath ?? group.basePath }], groups);
-        const mutationRecalc = scenarios.find(s => s.scenarioName.endsWith("-mutation-verify"));
-        expect(mutationRecalc).toBeDefined();
-        expect(mutationRecalc.category).toBe("new_endpoint");
-        expect(mutationRecalc.testType).toBe("integration");
-        expect(mutationRecalc.priority).toBe("high");
-        // Step 1: POST to create resource (all test cases have POST)
-        expect(mutationRecalc.steps[0].method).toBe("POST");
-        expect(mutationRecalc.steps[0].path).toBe(group.basePath);
-        // Step 2: PUT/PATCH with mutation
-        const mutationStep = mutationRecalc.steps[1];
-        expect(mutationStep.method).toBe(method);
-        // Note: bodyMustInclude removed in intent-based refactor - LLM discovers fields from source
-        // Verify NO hardcoded domain-specific field names
-        // Verify hints are descriptive (contain "e.g." or similar guidance)
-        // Chaining uses the actual path param name (only when paramPath exists)
-        if (group.paramPath) {
-            expect(mutationStep.chainsFrom).toBeDefined();
-            const chaining = mutationStep.chainsFrom;
-            expect(chaining.targetParam).toBe(expectedParamName);
-            expect(chaining.sourceStep).toBe(1);
-            expect(chaining.sourceField).toBe("id");
-        }
-        else {
-            expect(mutationStep.chainsFrom).toBeUndefined();
-        }
-        // Step 3: GET verification (if paramPath exists)
-        if (group.paramPath) {
-            expect(mutationRecalc.steps).toHaveLength(3);
-            const getStep = mutationRecalc.steps[2];
-            expect(getStep.method).toBe("GET");
-            // Note: expectedResponseFields removed in intent-based refactor
-        }
-        // chainingKeys uses the actual path param name, not hardcoded singular_id
-        expect(mutationRecalc.chainingKeys).toContain("id");
-        expect(mutationRecalc.chainingKeys).toContain(expectedParamName);
-        // Description is domain-agnostic
-        expect(mutationRecalc.description).toContain("Mutation test");
-        expect(mutationRecalc.description).toContain("derived calculations");
-    });
-    it("no paramPath: PATCH step targets basePath, no GET verification, fallback param name", () => {
+    it("/products/search → falls back to 'products' resource", () => {
         const groups = makeGroups({
-            items: { basePath: "/items", methods: ["GET", "POST", "PATCH"] },
+            products: { basePath: "/api/v1/products", methods: ["GET", "POST"], paramPath: "/api/v1/products/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PATCH", path: "/items" }], groups);
-        const mutationRecalc = scenarios.find(s => s.scenarioName.endsWith("-mutation-verify"));
-        expect(mutationRecalc).toBeDefined();
-        // No paramPath → PATCH targets basePath, no GET step
-        expect(mutationRecalc.steps).toHaveLength(2);
-        expect(mutationRecalc.steps[1].path).toBe("/items");
-        // Fallback param name: singular + _id
-        expect(mutationRecalc.chainingKeys).toContain("item_id");
+        const result = draftMinimalScenarios([{ method: "GET", path: "/api/v1/products/search" }], groups, "new_endpoint");
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some(s => s.scenarioName.includes("products"))).toBe(true);
     });
-    it("resource without POST: no create step, no chaining", () => {
+    it("/links/archive → falls back to 'links' resource", () => {
         const groups = makeGroups({
-            configs: { basePath: "/api/configs", methods: ["GET", "PATCH"], paramPath: "/api/configs/{config_id}" },
+            links: { basePath: "/api/v1/links", methods: ["GET", "POST", "PUT"], paramPath: "/api/v1/links/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PATCH", path: "/api/configs/{config_id}" }], groups);
-        const mutationRecalc = scenarios.find(s => s.scenarioName.endsWith("-mutation-verify"));
-        expect(mutationRecalc).toBeDefined();
-        // No POST → starts with PATCH directly, no chaining
-        expect(mutationRecalc.steps[0].method).toBe("PATCH");
-        expect(mutationRecalc.steps[0].chainsFrom).toBeUndefined();
-        // Still has GET verification
-        expect(mutationRecalc.steps[1].method).toBe("GET");
-        expect(mutationRecalc.steps[1].chainsFrom).toBeUndefined();
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/v1/links/archive" }], groups, "new_endpoint");
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some(s => s.scenarioName.includes("links"))).toBe(true);
     });
-    it("generates auth-boundary scenario for each new endpoint (security_boundary, not new_endpoint)", () => {
+    it("/health generates a scenario even without a matching group (LLM validates)", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT"], paramPath: "/api/orders/{order_id}" },
+            users: { basePath: "/api/users", methods: ["GET", "POST"] },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }], groups);
-        const authBoundary = scenarios.find(s => s.scenarioName === "orders-put-auth-boundary");
-        expect(authBoundary).toBeDefined();
-        expect(authBoundary.category).toBe("security_boundary");
-        expect(authBoundary.testType).toBe("contract");
-        expect(authBoundary.steps[0].method).toBe("PUT");
-        expect(authBoundary.steps[0].path).toBe("/api/orders/{order_id}");
-        expect(authBoundary.steps[0].expectedStatusCode).toBe(401);
-        expect(authBoundary.requiresAuth).toBe(false);
+        const result = draftMinimalScenarios([{ method: "GET", path: "/health" }], groups, "new_endpoint");
+        expect(result).toHaveLength(1); // GET → contract only
+        expect(result[0].steps[0].path).toBe("/health");
     });
-    it("auth-boundary scenario is not duplicated for same method/path", () => {
+    it("same action sub-path under different resources → both resolve correctly", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["GET", "POST", "PUT", "DELETE"], paramPath: "/api/orders/{order_id}" },
+            products: { basePath: "/api/products", methods: ["GET", "POST"], paramPath: "/api/products/{id}" },
+            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "PUT", path: "/api/orders/{order_id}" }, { method: "DELETE", path: "/api/orders/{order_id}" }], groups);
-        const authBoundaries = scenarios.filter(s => s.scenarioName.includes("auth-boundary"));
-        // One for PUT, one for DELETE (not GET, not POST)
-        expect(authBoundaries).toHaveLength(2);
-        expect(authBoundaries.map(s => s.scenarioName).sort()).toEqual([
-            "orders-delete-auth-boundary",
-            "orders-put-auth-boundary",
-        ]);
+        const result = draftMinimalScenarios([
+            { method: "GET", path: "/api/products/search" },
+            { method: "GET", path: "/api/orders/search" },
+        ], groups, "new_endpoint");
+        expect(result).toHaveLength(2);
+        const names = result.map(s => s.scenarioName);
+        expect(names[0]).not.toBe(names[1]);
+        expect(names.some(n => n.includes("products"))).toBe(true);
+        expect(names.some(n => n.includes("orders"))).toBe(true);
     });
-    it("does NOT generate auth-boundary for GET endpoints (often public)", () => {
+    it("/api/v1/payments → 'payments' is a real resource, generates scenarios", () => {
         const groups = makeGroups({
-            orders: { basePath: "/api/orders", methods: ["GET", "POST"], paramPath: "/api/orders/{order_id}" },
+            payments: { basePath: "/api/v1/payments", methods: ["GET", "POST"], paramPath: "/api/v1/payments/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "GET", path: "/api/orders/{order_id}" }], groups);
-        const authBoundary = scenarios.find(s => s.scenarioName.includes("auth-boundary"));
-        expect(authBoundary).toBeUndefined();
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/v1/payments" }], groups, "new_endpoint");
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some(s => s.scenarioName.includes("payments"))).toBe(true);
     });
-    it("does NOT generate auth-boundary for POST", () => {
+    it("/api/v1/webhooks → 'webhooks' is a real resource, generates scenarios", () => {
         const groups = makeGroups({
-            products: { basePath: "/api/products", methods: ["GET", "POST"], paramPath: "/api/products/{id}" },
+            webhooks: { basePath: "/api/v1/webhooks", methods: ["GET", "POST"], paramPath: "/api/v1/webhooks/{id}" },
         });
-        const scenarios = draftDiffDirectScenarios([{ method: "POST", path: "/api/products" }], groups);
-        const authBoundary = scenarios.find(s => s.scenarioName.includes("auth-boundary"));
-        expect(authBoundary).toBeUndefined();
+        const result = draftMinimalScenarios([{ method: "POST", path: "/api/v1/webhooks" }], groups, "new_endpoint");
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some(s => s.scenarioName.includes("webhooks"))).toBe(true);
     });
 });
-describe("draftDiffDirectScenarios — GET without path param", () => {
-    const resourceGroups = new Map([
-        ["products", {
-                basePath: "/api/v1/products",
-                methods: new Set(["GET", "POST"]),
-                paramPath: "/api/v1/products/{product_id}",
-            }],
-    ]);
-    it("GET no-param: produces contract + collection scenario (LLM determines if query params apply)", () => {
-        const result = draftDiffDirectScenarios([{ method: "GET", path: "/api/v1/products/search" }], resourceGroups);
-        const names = result.map(s => s.scenarioName);
-        expect(names).toContain("products-get-new-endpoint-contract");
-        expect(names).toContain("products-search-list-query");
-        const scenario = result.find(s => s.scenarioName === "products-search-list-query");
-        expect(scenario.category).toBe("new_endpoint");
-        // Description instructs LLM to read source for query param logic
-        expect(scenario.description).toMatch(/read diff source|query param/i);
+// ---------------------------------------------------------------------------
+// draftScenariosFromEndpoints — integration tests
+// ---------------------------------------------------------------------------
+describe("draftScenariosFromEndpoints", () => {
+    it("returns empty array for no endpoints", () => {
+        expect(draftScenariosFromEndpoints([])).toEqual([]);
     });
-    it("GET no-param: produces zero cascade-delete or unique-constraint scenarios", () => {
-        const result = draftDiffDirectScenarios([{ method: "GET", path: "/api/v1/products/search" }], resourceGroups);
-        const names = result.map(s => s.scenarioName);
-        expect(names.some(n => n.includes("cascade"))).toBe(false);
-        expect(names.some(n => n.includes("unique"))).toBe(false);
-        expect(names.some(n => n.includes("delete-blocked"))).toBe(false);
+    it("passes newEndpoints through as new_endpoint category", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: ["GET", "POST", "PUT"] },
+            { path: "/api/orders/{order_id}", methods: ["GET", "PUT", "DELETE"] },
+        ];
+        const newEndpoints = [{ method: "PUT", path: "/api/orders/{order_id}" }];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
+        const newScenarios = result.filter(s => s.category === "new_endpoint");
+        expect(newScenarios.length).toBeGreaterThan(0);
+        expect(newScenarios.some(s => s.steps.some(st => st.method === "PUT"))).toBe(true);
     });
-    it("collection GET with POST: produces integration scenario (POST then GET)", () => {
-        const result = draftDiffDirectScenarios([{ method: "GET", path: "/api/v1/products" }], resourceGroups);
-        const scenario = result.find(s => s.scenarioName === "products-list-query");
-        expect(scenario).toBeDefined();
-        expect(scenario.testType).toBe("integration");
-        expect(scenario.steps[0].method).toBe("POST");
-        expect(scenario.steps[1].method).toBe("GET");
+    it("changed + new endpoints on same resource → new takes priority (no duplicates)", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "GET" }, { method: "POST" }, { method: "PUT" }] },
+            { path: "/api/orders/{order_id}", methods: [{ method: "GET" }, { method: "PUT" }, { method: "DELETE" }] },
+        ];
+        const newEndpoints = [{ method: "PUT", path: "/api/orders/{order_id}" }];
+        const changedEndpoints = [{ method: "PUT", path: "/api/orders/{order_id}" }];
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints, changedEndpoints);
+        const putScenarios = result.filter(s => s.steps.some(st => st.method === "PUT"));
+        const newPut = putScenarios.filter(s => s.category === "new_endpoint");
+        const changedPut = putScenarios.filter(s => s.category === "business_rule");
+        expect(newPut.length).toBeGreaterThan(0);
+        expect(changedPut.length).toBe(0); // deduped — new takes priority
+    });
+    it("changed endpoints produce scenarios even when no new endpoints exist", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/orders/{order_id}", methods: [{ method: "GET" }, { method: "PATCH" }] },
+        ];
+        const result = draftScenariosFromEndpoints(endpoints, [], [
+            { method: "PATCH", path: "/api/orders/{order_id}" },
+        ]);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.every(s => s.category === "business_rule")).toBe(true);
     });
-    it("collection GET without POST: produces contract scenario (single GET step)", () => {
-        const readOnlyGroups = new Map([
-            ["reports", {
-                    basePath: "/api/v1/reports",
-                    methods: new Set(["GET"]),
-                    paramPath: undefined,
-                }],
+    it("modified GET → contract only; modified PUT → contract + integration", () => {
+        const endpoints = [
+            { path: "/api/orders", methods: [{ method: "GET" }, { method: "POST" }, { method: "PUT" }] },
+            { path: "/api/orders/{order_id}", methods: [{ method: "GET" }, { method: "PUT" }] },
+        ];
+        const result = draftScenariosFromEndpoints(endpoints, [], [
+            { method: "GET", path: "/api/orders/{order_id}" },
+            { method: "PUT", path: "/api/orders/{order_id}" },
+        ]);
+        const getScenarios = result.filter(s => s.steps[0].method === "GET");
+        const putScenarios = result.filter(s => s.steps[0].method === "PUT");
+        expect(getScenarios).toHaveLength(1); // contract only
+        expect(putScenarios).toHaveLength(2); // contract + integration
+    });
+    it("unrelated endpoints sharing last segment both produce scenarios", () => {
+        // /products/search and /orders/search both extract "search" as resource name.
+        // Without disambiguated keys, the second endpoint is silently dropped.
+        const endpoints = [
+            { path: "/api/products/search", methods: ["GET"] },
+            { path: "/api/orders/search", methods: ["GET"] },
+        ];
+        const result = draftScenariosFromEndpoints(endpoints, [
+            { method: "GET", path: "/api/products/search" },
+            { method: "GET", path: "/api/orders/search" },
         ]);
-        const result = draftDiffDirectScenarios([{ method: "GET", path: "/api/v1/reports" }], readOnlyGroups);
-        const scenario = result.find(s => s.scenarioName === "reports-list-query");
-        expect(scenario).toBeDefined();
-        expect(scenario.testType).toBe("contract");
-        expect(scenario.steps).toHaveLength(1);
+        expect(result).toHaveLength(2);
+        const paths = result.map(s => s.steps[0].path);
+        expect(paths).toContain("/api/products/search");
+        expect(paths).toContain("/api/orders/search");
     });
 });
 // ---------------------------------------------------------------------------
 // capScenarios — enforced via draftScenariosFromEndpoints
 // ---------------------------------------------------------------------------
 describe("draftScenariosFromEndpoints — capScenarios hard limit", () => {
-    // Each PUT/PATCH new endpoint produces ~5 scenarios (mutation-verify, boundary-values,
-    // contract, not-found, auth-boundary). Seven resources × 2 methods each = 70 new
-    // endpoints → well above the 30-scenario cap.
     function makeEndpointsAndNewEps(resourceNames) {
         const endpoints = resourceNames.flatMap(r => [
             { path: `/api/${r}`, methods: [{ method: "GET" }, { method: "POST" }] },
@@ -532,6 +309,8 @@ describe("draftScenariosFromEndpoints — capScenarios hard limit", () => {
         const newEndpoints = resourceNames.flatMap(r => [
             { method: "PUT", path: `/api/${r}/{id}` },
             { method: "PATCH", path: `/api/${r}/{id}` },
+            { method: "POST", path: `/api/${r}` },
+            { method: "DELETE", path: `/api/${r}/{id}` },
         ]);
         return { endpoints, newEndpoints };
     }
@@ -545,24 +324,9 @@ describe("draftScenariosFromEndpoints — capScenarios hard limit", () => {
         const resources = ["users", "products", "orders", "invoices", "shipments", "reviews", "payments", "discounts"];
         const { endpoints, newEndpoints } = makeEndpointsAndNewEps(resources);
         const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
-        // new_endpoint is CRITICAL — verify at least some survive
         const criticalOnes = result.filter((s) => s.category === "new_endpoint");
         expect(criticalOnes.length).toBeGreaterThan(0);
     });
-    it("CRITICAL items (new_endpoint) fill the cap first; security_boundary may be dropped", () => {
-        // With many new endpoints, diffDirectContract/NotFound/MutationVerify/BoundaryValues all
-        // produce category "new_endpoint" (CRITICAL). When CRITICAL items alone exceed 30, the hard
-        // cap slices them first — breadth picks for non-CRITICAL categories are not guaranteed.
-        const resources = ["users", "products", "orders", "invoices", "shipments", "reviews", "payments", "discounts"];
-        const { endpoints, newEndpoints } = makeEndpointsAndNewEps(resources);
-        const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
-        // All 30 surviving scenarios should be CRITICAL (new_endpoint)
-        const nonCritical = result.filter((s) => s.category !== "new_endpoint");
-        // Non-critical (security_boundary) may be 0 — this is the documented cap behavior
-        expect(nonCritical.length).toBeLessThanOrEqual(result.length);
-        // And the cap is enforced
-        expect(result.length).toBeLessThanOrEqual(30);
-    });
     it("does not cap when total scenarios are within the limit", () => {
         const endpoints = [
             { path: "/api/users", methods: [{ method: "GET" }, { method: "POST" }] },
@@ -572,8 +336,24 @@ describe("draftScenariosFromEndpoints — capScenarios hard limit", () => {
             { method: "PUT", path: "/api/users/{id}" },
         ];
         const result = draftScenariosFromEndpoints(endpoints, newEndpoints);
-        // A single PUT endpoint produces 5 scenarios — well within the 30-scenario cap
         expect(result.length).toBeLessThanOrEqual(30);
-        expect(result.length).toBeGreaterThanOrEqual(4);
+        expect(result.length).toBe(2); // contract + integration
+    });
+    it("respects MAX_TOTAL_SCENARIOS with combined new+changed", () => {
+        const resources = ["users", "products", "orders", "invoices", "shipments", "reviews", "payments", "discounts"];
+        const endpoints = resources.flatMap(r => [
+            { path: `/api/${r}`, methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: `/api/${r}/{id}`, methods: [{ method: "GET" }, { method: "PUT" }, { method: "PATCH" }, { method: "DELETE" }] },
+        ]);
+        const newEndpoints = resources.slice(0, 4).flatMap(r => [
+            { method: "PUT", path: `/api/${r}/{id}` },
+            { method: "POST", path: `/api/${r}` },
+        ]);
+        const changedEndpoints = resources.slice(4).flatMap(r => [
+            { method: "PATCH", path: `/api/${r}/{id}` },
+            { method: "GET", path: `/api/${r}/{id}` },
+        ]);
+        const result = draftScenariosFromEndpoints(endpoints, newEndpoints, changedEndpoints);
+        expect(result.length).toBeLessThanOrEqual(30);
     });
 });