@gnapi/cotester 1.2.3 → 1.2.5

package/dist/frameworkAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Abstracts test-framework-specific syntax so the generator can emit
+ * either Jest or Vitest output without conditional logic scattered everywhere.
+ */
+export interface TestFrameworkAdapter {
+    /** Top-level import line(s) required by the framework (empty for Jest). */
+    frameworkImport(): string;
+    /** Produce `jest.mock(...)` / `vi.mock(...)` call for a module. */
+    mockModule(importPath: string, importedNames: string[]): string;
+    /** Check string used to detect an existing mock in a file. */
+    mockModuleCheck(importPath: string): string;
+    /** `jest.fn()` / `vi.fn()` */
+    mockFn(): string;
+    /** `jest.clearAllMocks()` / `vi.clearAllMocks()` */
+    clearAllMocks(): string;
+    /**
+     * Cast expression prefix for setting up a mock return value on a named import.
+     * Jest: `(name as jest.Mock)`
+     * Vitest: `vi.mocked(name)`
+     */
+    mockCast(name: string): string;
+    /** `<cast>.mockResolvedValue(val)` */
+    mockResolvedValue(name: string, val: string): string;
+    /** `<cast>.mockReturnValue(val)` */
+    mockReturnValue(name: string, val: string): string;
+    /** `jest.fn().mockReturnValue(val)` / `vi.fn().mockReturnValue(val)` — for inline chained stubs */
+    mockFnReturnValue(val: string): string;
+}
+export declare class JestAdapter implements TestFrameworkAdapter {
+    frameworkImport(): string;
+    mockModule(importPath: string, importedNames: string[]): string;
+    mockModuleCheck(importPath: string): string;
+    mockFn(): string;
+    clearAllMocks(): string;
+    mockCast(name: string): string;
+    mockResolvedValue(name: string, val: string): string;
+    mockReturnValue(name: string, val: string): string;
+    mockFnReturnValue(val: string): string;
+}
+export declare class VitestAdapter implements TestFrameworkAdapter {
+    frameworkImport(): string;
+    mockModule(importPath: string, importedNames: string[]): string;
+    mockModuleCheck(importPath: string): string;
+    mockFn(): string;
+    clearAllMocks(): string;
+    mockCast(name: string): string;
+    mockResolvedValue(name: string, val: string): string;
+    mockReturnValue(name: string, val: string): string;
+    mockFnReturnValue(val: string): string;
+}
+export declare function createAdapter(framework?: "jest" | "vitest"): TestFrameworkAdapter;

package/dist/frameworkAdapter.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Abstracts test-framework-specific syntax so the generator can emit
+ * either Jest or Vitest output without conditional logic scattered everywhere.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VitestAdapter = exports.JestAdapter = void 0;
+exports.createAdapter = createAdapter;
+// ── Jest adapter ──────────────────────────────────────────────────────────────
+class JestAdapter {
+    frameworkImport() {
+        return "";
+    }
+    mockModule(importPath, importedNames) {
+        const fns = importedNames.map((n) => `  ${n}: jest.fn(),`).join("\n");
+        return `jest.mock('${importPath}', () => ({\n${fns}\n}));`;
+    }
+    mockModuleCheck(importPath) {
+        return `jest.mock('${importPath}'`;
+    }
+    mockFn() {
+        return "jest.fn()";
+    }
+    clearAllMocks() {
+        return "jest.clearAllMocks();";
+    }
+    mockCast(name) {
+        return `(${name} as jest.Mock)`;
+    }
+    mockResolvedValue(name, val) {
+        return `${this.mockCast(name)}.mockResolvedValue(${val});`;
+    }
+    mockReturnValue(name, val) {
+        return `${this.mockCast(name)}.mockReturnValue(${val});`;
+    }
+    mockFnReturnValue(val) {
+        return `jest.fn().mockReturnValue(${val})`;
+    }
+}
+exports.JestAdapter = JestAdapter;
+// ── Vitest adapter ────────────────────────────────────────────────────────────
+class VitestAdapter {
+    frameworkImport() {
+        return "import { describe, test, expect, vi, beforeEach } from 'vitest';";
+    }
+    mockModule(importPath, importedNames) {
+        const fns = importedNames.map((n) => `  ${n}: vi.fn(),`).join("\n");
+        return `vi.mock('${importPath}', () => ({\n${fns}\n}));`;
+    }
+    mockModuleCheck(importPath) {
+        return `vi.mock('${importPath}'`;
+    }
+    mockFn() {
+        return "vi.fn()";
+    }
+    clearAllMocks() {
+        return "vi.clearAllMocks();";
+    }
+    mockCast(name) {
+        return `vi.mocked(${name})`;
+    }
+    mockResolvedValue(name, val) {
+        return `${this.mockCast(name)}.mockResolvedValue(${val});`;
+    }
+    mockReturnValue(name, val) {
+        return `${this.mockCast(name)}.mockReturnValue(${val});`;
+    }
+    mockFnReturnValue(val) {
+        return `vi.fn().mockReturnValue(${val})`;
+    }
+}
+exports.VitestAdapter = VitestAdapter;
+// ── Factory ───────────────────────────────────────────────────────────────────
+function createAdapter(framework = "jest") {
+    return framework === "vitest" ? new VitestAdapter() : new JestAdapter();
+}
+//# sourceMappingURL=frameworkAdapter.js.map

package/dist/frameworkAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameworkAdapter.js","sourceRoot":"","sources":["../src/frameworkAdapter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAuHH,sCAEC;AAtFD,iFAAiF;AAEjF,MAAa,WAAW;IACpB,eAAe;QACX,OAAO,EAAE,CAAC;IACd,CAAC;IAED,UAAU,CAAC,UAAkB,EAAE,aAAuB;QAClD,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtE,OAAO,cAAc,UAAU,gBAAgB,GAAG,QAAQ,CAAC;IAC/D,CAAC;IAED,eAAe,CAAC,UAAkB;QAC9B,OAAO,cAAc,UAAU,GAAG,CAAC;IACvC,CAAC;IAED,MAAM;QACF,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,aAAa;QACT,OAAO,uBAAuB,CAAC;IACnC,CAAC;IAED,QAAQ,CAAC,IAAY;QACjB,OAAO,IAAI,IAAI,gBAAgB,CAAC;IACpC,CAAC;IAED,iBAAiB,CAAC,IAAY,EAAE,GAAW;QACvC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IAC/D,CAAC;IAED,eAAe,CAAC,IAAY,EAAE,GAAW;QACrC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAC7D,CAAC;IAED,iBAAiB,CAAC,GAAW;QACzB,OAAO,6BAA6B,GAAG,GAAG,CAAC;IAC/C,CAAC;CACJ;AArCD,kCAqCC;AAED,iFAAiF;AAEjF,MAAa,aAAa;IACtB,eAAe;QACX,OAAO,kEAAkE,CAAC;IAC9E,CAAC;IAED,UAAU,CAAC,UAAkB,EAAE,aAAuB;QAClD,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpE,OAAO,YAAY,UAAU,gBAAgB,GAAG,QAAQ,CAAC;IAC7D,CAAC;IAED,eAAe,CAAC,UAAkB;QAC9B,OAAO,YAAY,UAAU,GAAG,CAAC;IACrC,CAAC;IAED,MAAM;QACF,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,aAAa;QACT,OAAO,qBAAqB,CAAC;IACjC,CAAC;IAED,QAAQ,CAAC,IAAY;QACjB,OAAO,aAAa,IAAI,GAAG,CAAC;IAChC,CAAC;IAED,iBAAiB,CAAC,IAAY,EAAE,GAAW;QACvC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IAC/D,CAAC;IAED,eAAe,CAAC,IAAY,EAAE,GAAW;QACrC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAC7D,CAAC;IAED,iBAAiB,CAAC,GAAW;QACzB,OAAO,2BAA2B,GAAG,GAAG,CAAC;IAC7C,CAAC;CACJ;AArCD,sCAqCC;AAED,iFAAiF;AAEjF,SAAgB,aAAa,CAAC,YAA+B,MAAM;IAC/D,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC;AAC5E,CAAC"}

package/dist/generator.d.ts

@@ -13,4 +13,4 @@ import { MockFileResult } from "./mockGenerator";
  * Individual functions/methods that already have a describe block are never
  * touched, preserving any hand-written assertions inside them.
  */
-export declare function generateTestFile(srcFilePath: string, scenarios: TestScenario[], projectRoot: string, srcDir: string, testDir: string, mockResult: MockFileResult | null, tableThreshold?: number): Promise<string | null>;
+export declare function generateTestFile(srcFilePath: string, scenarios: TestScenario[], projectRoot: string, srcDir: string, testDir: string, mockResult: MockFileResult | null, tableThreshold?: number, dryRun?: boolean, framework?: "jest" | "vitest", snapshotForComplexTypes?: boolean): Promise<string | null>;

package/dist/generator.js

@@ -39,6 +39,7 @@ 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),
@@ -58,23 +59,35 @@ 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) {
+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, 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;
+    }
     (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;
     }
     // ── 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.
@@ -87,7 +100,7 @@ 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 ──
@@ -129,7 +142,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 {
@@ -137,7 +150,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);
@@ -146,7 +159,7 @@ 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));
     }
     if (toAppend.length === 0 && newScenarios.length === 0) {
         (0, utils_1.log)(`  ${path.relative(projectRoot, testFilePath)} — all functions already covered.`, "info");
@@ -156,8 +169,8 @@ async function mergeIntoExistingTestFile(scenarios, srcFilePath, testFilePath, m
     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;
@@ -271,17 +284,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) {
@@ -305,24 +317,25 @@ 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("");
+    // ── 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 ────────────────────────────────────
@@ -371,18 +384,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};`);
@@ -395,19 +408,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`);
@@ -425,7 +440,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)}`)
@@ -446,66 +461,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("});");
@@ -539,7 +554,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;
@@ -563,7 +578,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}`);
     }
@@ -571,18 +586,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;
@@ -592,21 +607,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("");
@@ -644,17 +667,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}`);
         }
@@ -763,7 +797,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 = [];
@@ -802,6 +851,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;
 }
@@ -811,6 +863,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();