@gnapi/cotester 1.2.4 → 1.2.6

package/dist/generator.js

@@ -33,18 +33,27 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_MARKER = exports.CURRENT_FILE_VERSION = exports.TESTGEN_MARKER = void 0;
 exports.generateTestFile = generateTestFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const formatter_1 = require("./formatter");
 const utils_1 = require("./utils");
 const ormMockGenerator_1 = require("./ormMockGenerator");
+const frameworkAdapter_1 = require("./frameworkAdapter");
 /**
  * Marker placed as the very first line of every generated test file.
  * Its presence lets cotester know the file was scaffolded (not hand-written),
  * but function-level merging works regardless of whether the marker is present.
  */
-const TESTGEN_MARKER = "// @cotester-generated";
+exports.TESTGEN_MARKER = "// @cotester-generated";
+/**
+ * Format version written into the second line of every generated test file.
+ * Used by `cotester migrate` to detect files produced by older versions and
+ * upgrade them in-place.  Increment this when the generated format changes.
+ */
+exports.CURRENT_FILE_VERSION = 2;
+exports.VERSION_MARKER = `// @cotester-version: ${exports.CURRENT_FILE_VERSION}`;
 /**
  * Generate (or merge into) a test file for the given source file.
  *
@@ -58,34 +67,37 @@ const TESTGEN_MARKER = "// @cotester-generated";
  * Individual functions/methods that already have a describe block are never
  * touched, preserving any hand-written assertions inside them.
  */
-async function generateTestFile(srcFilePath, scenarios, projectRoot, srcDir, testDir, mockResult, tableThreshold = 0, dryRun = false) {
+async function generateTestFile(srcFilePath, scenarios, projectRoot, srcDir, testDir, mockResult, tableThreshold = 0, dryRun = false, framework = "jest", snapshotForComplexTypes = false) {
     if (scenarios.length === 0) {
         return null;
     }
+    const adapter = (0, frameworkAdapter_1.createAdapter)(framework);
     const absSrcRoot = path.resolve(projectRoot, srcDir);
     const testFilePath = (0, utils_1.mirrorPath)(srcFilePath, absSrcRoot, path.join(projectRoot, testDir), ".test.ts");
     // ── Dry-run: print generated content without touching the filesystem ──
     if (dryRun) {
-        const code = buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold);
+        const code = buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold, adapter, snapshotForComplexTypes);
         const formatted = await (0, formatter_1.formatCode)(code, projectRoot);
         const relTest = path.relative(projectRoot, testFilePath).replace(/\\/g, "/");
         process.stdout.write(`\n${"─".repeat(60)}\n`);
         process.stdout.write(`// [dry-run] Test file: ${relTest}\n`);
         process.stdout.write(`${"─".repeat(60)}\n`);
         process.stdout.write(formatted);
-        return testFilePath;
+        const allNames = scenarios.map((s) => s.functionName);
+        return { testFilePath, added: allNames, merged: [], skipped: [] };
     }
     (0, utils_1.ensureDir)(path.dirname(testFilePath));
     // ── Brand-new file → generate everything ─────────────────────────────
     if (!fs.existsSync(testFilePath)) {
-        const code = buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold);
+        const code = buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold, adapter, snapshotForComplexTypes);
         const formatted = await (0, formatter_1.formatCode)(code, projectRoot);
         fs.writeFileSync(testFilePath, formatted, "utf-8");
         (0, utils_1.log)(`Test file → ${path.relative(projectRoot, testFilePath)}`, "success");
-        return testFilePath;
+        const allNames = scenarios.map((s) => s.functionName);
+        return { testFilePath, added: allNames, merged: [], skipped: [] };
     }
     // ── File exists → function-level merge ───────────────────────────────
-    return mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold);
+    return mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold, adapter, snapshotForComplexTypes);
 }
 /**
  * Merge missing function/method describe blocks into an already-existing test file.
@@ -98,11 +110,12 @@ async function generateTestFile(srcFilePath, scenarios, projectRoot, srcDir, tes
  *  5. For entire new classes → append a full class describe block.
  *  6. For any new dependencies (jest.mock) not already in the file → prepend them.
  */
-async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold = 0) {
+async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     let content = fs.readFileSync(testFilePath, "utf-8");
     const existingDescribes = detectExistingDescribes(content);
     // ── Feature 6: signature-change detection for already-covered describes ──
     const existingSigs = parseExistingSignatures(content);
+    const sigChangedNames = new Set();
     for (const s of scenarios) {
         const key = s.functionName;
         if (!existingDescribes.has(key))
@@ -118,6 +131,7 @@ async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, m
             (0, utils_1.log)(`  Signature changed for ${key} — injecting update warning.`, "warn");
             content = updateSignatureComment(content, key, newSig);
             content = injectSignatureWarning(content, key, oldSig, newSig);
+            sigChangedNames.add(key);
         }
     }
     // ── Classify scenarios ───────────────────────────────────────────────
@@ -140,7 +154,7 @@ async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, m
     for (const [className, methods] of classMap) {
         if (!existingDescribes.has(className)) {
             // Entire class is new → append full class describe block
-            toAppend.push(buildClassDescribe(className, methods, mockResult, tableThreshold));
+            toAppend.push(buildClassDescribe(className, methods, mockResult, tableThreshold, adapter, snapshotForComplexTypes));
             newScenarios.push(...methods);
         }
         else {
@@ -148,7 +162,7 @@ async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, m
             const missingMethods = methods.filter(m => !existingDescribes.has(m.functionName));
             if (missingMethods.length > 0) {
                 const methodBlocks = missingMethods
-                    .map(m => indentBlock(buildMethodDescribe(m, mockResult, tableThreshold), 1))
+                    .map(m => indentBlock(buildMethodDescribe(m, mockResult, tableThreshold, adapter, snapshotForComplexTypes), 1))
                     .join("\n\n");
                 content = injectIntoClassDescribe(content, className, methodBlocks);
                 newScenarios.push(...missingMethods);
@@ -157,23 +171,29 @@ async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, m
     }
     // ── Standalone missing functions ─────────────────────────────────────
     for (const fn of missingStandalone) {
-        toAppend.push(buildFunctionDescribe(fn, mockResult, tableThreshold));
-    }
+        toAppend.push(buildFunctionDescribe(fn, mockResult, tableThreshold, adapter, snapshotForComplexTypes));
+    }
+    // ── Build audit lists ────────────────────────────────────────────────
+    const addedNames = newScenarios.map((s) => s.functionName);
+    const mergedNames = Array.from(sigChangedNames);
+    const skippedNames = scenarios
+        .filter((s) => existingDescribes.has(s.functionName) &&
+        !sigChangedNames.has(s.functionName))
+        .map((s) => s.functionName);
     if (toAppend.length === 0 && newScenarios.length === 0) {
         (0, utils_1.log)(`  ${path.relative(projectRoot, testFilePath)} — all functions already covered.`, "info");
-        return testFilePath;
+        return { testFilePath, added: [], merged: mergedNames, skipped: skippedNames };
     }
     // ── Append standalone / new-class blocks ─────────────────────────────
     if (toAppend.length > 0) {
         content = content.trimEnd() + "\n\n" + toAppend.join("\n\n") + "\n";
     }
-    // ── Prepend missing jest.mock() / import lines ───────────────────────
-    content = addMissingMocks(content, newScenarios, srcFilePath, testFilePath);
+    // ── Prepend missing mock() / import lines ────────────────────────────
+    content = addMissingMocks(content, newScenarios, srcFilePath, testFilePath, adapter);
     const formatted = await (0, formatter_1.formatCode)(content, projectRoot);
     fs.writeFileSync(testFilePath, formatted, "utf-8");
-    const addedCount = newScenarios.length;
-    (0, utils_1.log)(`Test file updated → ${path.relative(projectRoot, testFilePath)} (+${addedCount} function(s))`, "success");
-    return testFilePath;
+    (0, utils_1.log)(`Test file updated → ${path.relative(projectRoot, testFilePath)} (+${addedNames.length} function(s))`, "success");
+    return { testFilePath, added: addedNames, merged: mergedNames, skipped: skippedNames };
 }
 // ─── Merge helpers ────────────────────────────────────────────────────────────
 /**
@@ -282,17 +302,16 @@ function injectIntoClassDescribe(content, className, newBlocks) {
  * are already mocked in the file. If not, prepend the missing jest.mock() calls
  * and import statements before the first existing import line.
  */
-function addMissingMocks(content, newScenarios, srcFilePath, testFilePath) {
+function addMissingMocks(content, newScenarios, srcFilePath, testFilePath, adapter = (0, frameworkAdapter_1.createAdapter)("jest")) {
     const allDeps = collectAllDependencies(newScenarios);
     const mockLines = [];
     const importLines = [];
     for (const dep of allDeps) {
         const depAbsPath = resolveDepPath(srcFilePath, dep.modulePath);
         const depImportPath = computeRelativeImport(depAbsPath, testFilePath);
-        if (!content.includes(`jest.mock('${depImportPath}'`) &&
-            !content.includes(`jest.mock("${depImportPath}"`)) {
-            const mockFns = dep.importedNames.map(n => `  ${n}: jest.fn(),`).join("\n");
-            mockLines.push(`jest.mock('${depImportPath}', () => ({\n${mockFns}\n}));`);
+        const checkStr = adapter.mockModuleCheck(depImportPath);
+        if (!content.includes(checkStr) && !content.includes(checkStr.replace("'", '"'))) {
+            mockLines.push(adapter.mockModule(depImportPath, dep.importedNames));
         }
         const names = dep.importedNames.filter(n => n !== "default");
         if (names.length > 0) {
@@ -316,24 +335,26 @@ function escapeForRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // ─── Build the full test source ──────────────────────────────────────────────
-function buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold = 0) {
+function buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, projectRoot, srcDir, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
     // Marker — presence of this line tells cotester the file is auto-generated
     // and safe to regenerate. Remove it to protect hand-written edits.
-    lines.push(TESTGEN_MARKER);
+    lines.push(exports.TESTGEN_MARKER);
+    lines.push(exports.VERSION_MARKER);
     lines.push("");
+    // ── Framework import (Vitest only; empty for Jest) ───────────────
+    const fwImport = adapter.frameworkImport();
+    if (fwImport) {
+        lines.push(fwImport);
+        lines.push("");
+    }
     // ── Collect all unique dependencies across scenarios ─────────────
     const allDeps = collectAllDependencies(scenarios);
-    // ── jest.mock() calls (must appear before imports) ───────────────
+    // ── mock() calls (must appear before imports) ────────────────────
     for (const dep of allDeps) {
         const depAbsPath = resolveDepPath(srcFilePath, dep.modulePath);
         const depImportPath = computeRelativeImport(depAbsPath, testFilePath);
-        const mockFns = dep.importedNames
-            .map((n) => `  ${n}: jest.fn(),`)
-            .join("\n");
-        lines.push(`jest.mock('${depImportPath}', () => ({`);
-        lines.push(mockFns);
-        lines.push(`}));`);
+        lines.push(adapter.mockModule(depImportPath, dep.importedNames));
         lines.push("");
     }
     // ── Import the source module ────────────────────────────────────
@@ -382,18 +403,18 @@ function buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, proje
     }
     // ── Standalone functions ────────────────────────────────────────
     for (const fn of standaloneFns) {
-        lines.push(buildFunctionDescribe(fn, mockResult, tableThreshold));
+        lines.push(buildFunctionDescribe(fn, mockResult, tableThreshold, adapter, snapshotForComplexTypes));
         lines.push("");
     }
     // ── Class methods ───────────────────────────────────────────────
     for (const [className, methods] of classMap) {
-        lines.push(buildClassDescribe(className, methods, mockResult, tableThreshold));
+        lines.push(buildClassDescribe(className, methods, mockResult, tableThreshold, adapter, snapshotForComplexTypes));
         lines.push("");
     }
     return lines.join("\n");
 }
 // ─── Class describe block with constructor DI ────────────────────────────────
-function buildClassDescribe(className, methods, mockResult, tableThreshold = 0) {
+function buildClassDescribe(className, methods, mockResult, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
     lines.push(`describe(${JSON.stringify(className)}, () => {`);
     lines.push(`  let instance: ${className};`);
@@ -406,19 +427,21 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0)
         // If this constructor param matches the ORM variable, use ORM mocks
         if (ormUsage && (param.name === ormUsage.variableName || param.type.toLowerCase().includes(ormUsage.kind))) {
             const ormMocks = (0, ormMockGenerator_1.generateOrmMocks)(ormUsage);
-            // Add ORM mock if not already declared at file level
-            if (ormMocks.mockVarNames.length > 0) {
+            // Only alias if the file-level ORM var has a DIFFERENT name from the ctor param mock name
+            if (ormMocks.mockVarNames.length > 0 && ormMocks.mockVarNames[0] !== mockName) {
                 mockDeclarations.push(`  const ${mockName} = ${ormMocks.mockVarNames[0]}; // ORM mock`);
             }
-            else {
+            else if (ormMocks.mockVarNames.length === 0) {
                 mockDeclarations.push(`  const ${mockName} = { } as any; // TODO: add mock methods for ${param.type}`);
             }
+            // else: same name — variable already declared at file level; no re-declaration needed
         }
         else {
             // Generate smart mock based on type name
             const typeLower = param.type.toLowerCase();
             if (typeLower.includes("repository") || typeLower.includes("repo")) {
-                mockDeclarations.push(`  const ${mockName} = { find: jest.fn(), findById: jest.fn(), save: jest.fn(), create: jest.fn(), update: jest.fn(), delete: jest.fn() } as any;`);
+                const fn = adapter.mockFn();
+                mockDeclarations.push(`  const ${mockName} = { find: ${fn}, findById: ${fn}, save: ${fn}, create: ${fn}, update: ${fn}, delete: ${fn} } as any;`);
             }
             else if (typeLower.includes("service")) {
                 mockDeclarations.push(`  const ${mockName} = { } as any; // TODO: mock ${param.type} methods`);
@@ -436,7 +459,7 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0)
     }
     lines.push("");
     lines.push("  beforeEach(() => {");
-    lines.push("    jest.clearAllMocks();");
+    lines.push(`    ${adapter.clearAllMocks()}`);
     if (ctorParams.length > 0) {
         const args = ctorParams
             .map((p) => `mock${capitalize(p.name)}`)
@@ -457,66 +480,66 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0)
         lines.push("    params,");
         lines.push("    query,");
         lines.push("    headers: { 'Content-Type': 'application/json' },");
-        lines.push("    get: jest.fn(),");
+        lines.push(`    get: ${adapter.mockFn()},`);
         lines.push("  } as any);");
         lines.push("");
         lines.push("  const mockResponse = () => {");
         lines.push("    const res: any = {};");
-        lines.push("    res.status = jest.fn().mockReturnValue(res);");
-        lines.push("    res.json = jest.fn().mockReturnValue(res);");
-        lines.push("    res.send = jest.fn().mockReturnValue(res);");
-        lines.push("    res.set = jest.fn().mockReturnValue(res);");
+        lines.push(`    res.status = ${adapter.mockFnReturnValue("res")};`);
+        lines.push(`    res.json = ${adapter.mockFnReturnValue("res")};`);
+        lines.push(`    res.send = ${adapter.mockFnReturnValue("res")};`);
+        lines.push(`    res.set = ${adapter.mockFnReturnValue("res")};`);
         lines.push("    return res;");
         lines.push("  };");
         lines.push("");
-        lines.push("  const mockNext = jest.fn();");
+        lines.push(`  const mockNext = ${adapter.mockFn()};`);
     }
     lines.push("");
     for (const method of methods) {
-        lines.push(indentBlock(buildMethodDescribe(method, mockResult, tableThreshold), 1));
+        lines.push(indentBlock(buildMethodDescribe(method, mockResult, tableThreshold, adapter, snapshotForComplexTypes), 1));
         lines.push("");
     }
     lines.push("});");
     return lines.join("\n");
 }
 // ─── describe block for a standalone function ────────────────────────────────
-function buildFunctionDescribe(fn, mockResult, tableThreshold = 0) {
+function buildFunctionDescribe(fn, mockResult, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
     lines.push(`// @testgen-sig:${buildSignatureFingerprint(fn)}`);
     lines.push(`describe(${JSON.stringify(fn.functionName)}, () => {`);
     // Add beforeEach with clearAllMocks if this function has dependencies
     if (fn.dependencies.length > 0) {
         lines.push("  beforeEach(() => {");
-        lines.push("    jest.clearAllMocks();");
+        lines.push(`    ${adapter.clearAllMocks()}`);
         lines.push("  });");
         lines.push("");
     }
     const constName = mockResult?.constantNames.get(fn.functionName);
     const { tableCases, individualCases } = partitionCases(fn.cases, fn.parameters.length, tableThreshold);
     if (tableCases.length > 0) {
-        lines.push(indentBlock(buildTableBlock(fn, tableCases), 1));
+        lines.push(indentBlock(buildTableBlock(fn, tableCases, snapshotForComplexTypes), 1));
         lines.push("");
     }
     for (const c of individualCases) {
-        lines.push(indentBlock(buildTestBlock(fn, c, constName), 1));
+        lines.push(indentBlock(buildTestBlock(fn, c, constName, adapter, snapshotForComplexTypes), 1));
         lines.push("");
     }
     lines.push("});");
     return lines.join("\n");
 }
 // ─── describe block for a class method ───────────────────────────────────────
-function buildMethodDescribe(fn, mockResult, tableThreshold = 0) {
+function buildMethodDescribe(fn, mockResult, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
     lines.push(`// @testgen-sig:${buildSignatureFingerprint(fn)}`);
     lines.push(`describe(${JSON.stringify(fn.functionName)}, () => {`);
     const constName = mockResult?.constantNames.get(fn.functionName);
     const { tableCases, individualCases } = partitionCases(fn.cases, fn.parameters.length, tableThreshold);
     if (tableCases.length > 0) {
-        lines.push(indentBlock(buildTableBlock(fn, tableCases), 1));
+        lines.push(indentBlock(buildTableBlock(fn, tableCases, snapshotForComplexTypes), 1));
         lines.push("");
     }
     for (const c of individualCases) {
-        lines.push(indentBlock(buildTestBlock(fn, c, constName), 1));
+        lines.push(indentBlock(buildTestBlock(fn, c, constName, adapter, snapshotForComplexTypes), 1));
         lines.push("");
     }
     lines.push("});");
@@ -550,7 +573,7 @@ function partitionCases(cases, paramCount, tableThreshold) {
  * Emit a `test.each([...])('%s', ...)` block for a group of standard cases.
  * Each row is `[label, ...argLiterals]` so the Jest title shows the scenario name.
  */
-function buildTableBlock(scenario, tableCases) {
+function buildTableBlock(scenario, tableCases, snapshotForComplexTypes = false) {
     const lines = [];
     const isAsync = scenario.isAsync;
     const isMethod = !!scenario.className;
@@ -574,7 +597,7 @@ function buildTableBlock(scenario, tableCases) {
     lines.push(``);
     // Assert
     lines.push(`  // Assert`);
-    const expectLines = buildExpectStubs(scenario.returnType, "");
+    const expectLines = buildExpectStubs(scenario.returnType, "", snapshotForComplexTypes);
     for (const e of expectLines) {
         lines.push(`  ${e}`);
     }
@@ -582,18 +605,18 @@ function buildTableBlock(scenario, tableCases) {
     return lines.join("\n");
 }
 // ─── Individual test block ───────────────────────────────────────────────────
-function buildTestBlock(scenario, testCase, mockConstName) {
+function buildTestBlock(scenario, testCase, mockConstName, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     switch (testCase.kind) {
         case "throws":
             return buildThrowsBlock(scenario, testCase, mockConstName);
         case "rejects":
             return buildRejectsBlock(scenario, testCase, mockConstName);
         default:
-            return buildStandardBlock(scenario, testCase, mockConstName);
+            return buildStandardBlock(scenario, testCase, mockConstName, adapter, snapshotForComplexTypes);
     }
 }
 // ─── Standard test block (Arrange / Act / Assert) ────────────────────────────
-function buildStandardBlock(scenario, testCase, mockConstName) {
+function buildStandardBlock(scenario, testCase, mockConstName, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
     const fnName = scenario.functionName;
     const isAsync = scenario.isAsync;
@@ -603,21 +626,29 @@ function buildStandardBlock(scenario, testCase, mockConstName) {
     // ── Arrange ──────────────────────────────────────────────────────
     const caseKey = camelCase(testCase.label);
     if (isDependencyTest) {
-        // Emit mockReturnValue / mockResolvedValue so the SUT doesn't receive undefined
+        // Arrange: first declare input params from the first mock set's literals
+        const hasParams = testCase.paramNames.length > 0 && testCase.argLiterals.length > 0;
+        // Then set up mock return values for only the functions actually in importedFunctionMeta
         const mockSetupLines = [];
         for (const dep of scenario.dependencies) {
             for (const meta of dep.importedFunctionMeta) {
                 const mockVal = buildMockReturnValue(meta.returnType);
                 if (meta.isAsync) {
-                    mockSetupLines.push(`  (${meta.name} as jest.Mock).mockResolvedValue(${mockVal});`);
+                    mockSetupLines.push(`  ${adapter.mockResolvedValue(meta.name, mockVal)}`);
                 }
                 else {
-                    mockSetupLines.push(`  (${meta.name} as jest.Mock).mockReturnValue(${mockVal});`);
+                    mockSetupLines.push(`  ${adapter.mockReturnValue(meta.name, mockVal)}`);
                 }
             }
         }
-        if (mockSetupLines.length > 0) {
+        if (hasParams || mockSetupLines.length > 0) {
             lines.push("  // Arrange");
+            // Declare params so the function call compiles
+            if (hasParams) {
+                for (let i = 0; i < testCase.paramNames.length; i++) {
+                    lines.push(`  const ${testCase.paramNames[i]} = ${testCase.argLiterals[i] ?? "undefined"};`);
+                }
+            }
             for (const l of mockSetupLines)
                 lines.push(l);
             lines.push("");
@@ -655,17 +686,28 @@ function buildStandardBlock(scenario, testCase, mockConstName) {
     // ── Assert ──────────────────────────────────────────────────────
     lines.push("  // Assert");
     if (isDependencyTest) {
-        // Verify the mocked functions were called
+        // Verify only functions that the analyzer confirmed are called (have meta)
+        // This avoids asserting on imports the function never uses
         for (const dep of scenario.dependencies) {
-            for (const impName of dep.importedNames) {
-                if (impName !== "default") {
-                    lines.push(`  expect(${impName}).toHaveBeenCalled();`);
+            const metaList = dep.importedFunctionMeta.length > 0
+                ? dep.importedFunctionMeta
+                : dep.importedNames
+                    .filter(n => n !== "default")
+                    .map(n => ({ name: n, returnType: "unknown", isAsync: false, params: [] }));
+            for (const meta of metaList) {
+                const depParams = meta.params ?? [];
+                if (depParams.length > 0) {
+                    const callWithArgs = buildCalledWithArgs(depParams, testCase.paramNames, testCase.argLiterals);
+                    lines.push(`  expect(${meta.name}).toHaveBeenCalledWith(${callWithArgs});`);
+                }
+                else {
+                    lines.push(`  expect(${meta.name}).toHaveBeenCalled();`);
                 }
             }
         }
     }
     else {
-        const expectLines = buildExpectStubs(scenario.returnType, testCase.label);
+        const expectLines = buildExpectStubs(scenario.returnType, testCase.label, snapshotForComplexTypes);
         for (const e of expectLines) {
             lines.push(`  ${e}`);
         }
@@ -774,7 +816,22 @@ function buildMockReturnValue(returnType) {
     return "{ id: 1 }";
 }
 // ─── Expect stubs based on return type ───────────────────────────────────────
-function buildExpectStubs(returnType, scenarioLabel) {
+/** Primitive/built-in type names that do NOT warrant snapshot assertions. */
+const SNAPSHOT_SKIP_TYPES = new Set([
+    "number", "string", "boolean", "void", "undefined", "null",
+    "any", "never", "unknown", "object", "date", "record",
+]);
+function isComplexReturnType(unwrapped) {
+    const base = unwrapped.replace(/\[\]$/, "").replace(/<[^>]+>$/, "").trim();
+    if (SNAPSHOT_SKIP_TYPES.has(base))
+        return false;
+    if (base.startsWith("array") || base.startsWith("map") || base.startsWith("set") || base.startsWith("record"))
+        return false;
+    if (base.endsWith("[]"))
+        return false;
+    return true;
+}
+function buildExpectStubs(returnType, scenarioLabel, snapshotForComplexTypes = false) {
     const t = returnType.trim().toLowerCase();
     const unwrapped = unwrapType(t);
     const stubs = [];
@@ -813,6 +870,9 @@ function buildExpectStubs(returnType, scenarioLabel) {
     }
     else {
         stubs.push("expect(result).not.toBeNull();");
+        if (snapshotForComplexTypes && isComplexReturnType(unwrapped)) {
+            stubs.push("expect(result).toMatchSnapshot(); // Update snapshot after first run");
+        }
     }
     return stubs;
 }
@@ -822,6 +882,44 @@ function unwrapType(t) {
         return promiseMatch[1].trim();
     return t;
 }
+// ─── toHaveBeenCalledWith argument builder ────────────────────────────────────
+/**
+ * Build the argument list for `toHaveBeenCalledWith(...)`.
+ *
+ * Strategy (per dep function parameter):
+ *  1. If a SUT param with the same name and compatible type exists in the test's
+ *     arranged args, use that variable name (it was declared in Arrange).
+ *  2. Otherwise emit an `expect.any(Constructor)` / `expect.anything()` matcher.
+ */
+function buildCalledWithArgs(depParams, sutParamNames, sutArgLiterals) {
+    if (depParams.length === 0)
+        return "";
+    const args = depParams.map((dp) => {
+        // 1. Name match: SUT has a param with the same name
+        const nameIdx = sutParamNames.indexOf(dp.name);
+        if (nameIdx !== -1)
+            return dp.name;
+        // 2. Positional fallback: same position in param list
+        const posIdx = depParams.indexOf(dp);
+        if (posIdx < sutParamNames.length)
+            return sutParamNames[posIdx];
+        // 3. Type-based matcher
+        return typeToMatcher(dp.type);
+    });
+    return args.join(", ");
+}
+function typeToMatcher(typeStr) {
+    const t = typeStr.trim().toLowerCase().replace(/^promise<(.+)>$/i, "$1");
+    if (t === "number")
+        return "expect.any(Number)";
+    if (t === "string")
+        return "expect.any(String)";
+    if (t === "boolean")
+        return "expect.any(Boolean)";
+    if (t.endsWith("[]") || t.startsWith("array"))
+        return "expect.any(Array)";
+    return "expect.anything()";
+}
 // ─── Dependency helpers ──────────────────────────────────────────────────────
 function collectAllDependencies(scenarios) {
     const depMap = new Map();