@gnapi/cotester 1.2.10 → 1.2.12

package/dist/generator.js

@@ -37,6 +37,7 @@ exports.VERSION_MARKER = exports.CURRENT_FILE_VERSION = exports.TESTGEN_MARKER =
 exports.generateTestFile = generateTestFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
 const formatter_1 = require("./formatter");
 const utils_1 = require("./utils");
 const ormMockGenerator_1 = require("./ormMockGenerator");
@@ -391,6 +392,24 @@ function buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, proje
         lines.push(adapter.mockModule(depImportPath, dep.importedNames));
         lines.push("");
     }
+    // ── Auto-mock @nestjs/swagger to prevent decorator crashes ─────
+    // NestJS Swagger decorators call into metadata reflection at import time,
+    // which fails in a pure-Jest context. Mock the entire module with no-op
+    // decorator factories.
+    if (srcFilePath.includes(".controller.") ||
+        srcFilePath.includes(".dto.") ||
+        srcFilePath.includes("swagger") ||
+        allDeps.some(d => d.modulePath.includes("swagger") || d.modulePath.includes(".dto") || d.modulePath.includes(".controller"))) {
+        lines.push(`jest.mock('@nestjs/swagger', () => {`);
+        lines.push(`  const noop = () => (_target: any, _key?: any, _desc?: any) => _desc ?? _target;`);
+        lines.push(`  const noopClass = () => (target: any) => target;`);
+        lines.push(`  return new Proxy({}, { get: (_t, prop) => {`);
+        lines.push(`    if (prop === '__esModule') return true;`);
+        lines.push(`    return (...args: any[]) => args[0]?.constructor === Function || typeof args[0] === 'function' ? args[0] : noop();`);
+        lines.push(`  }});`);
+        lines.push(`});`);
+        lines.push(``);
+    }
     // ── Import the source module ────────────────────────────────────
     const importPath = computeRelativeImport(srcFilePath, testFilePath);
     const importNames = collectImportNames(scenarios);
@@ -450,11 +469,45 @@ function buildTestSource(scenarios, srcFilePath, testFilePath, mockResult, proje
 // ─── Class describe block with constructor DI ────────────────────────────────
 function buildClassDescribe(className, methods, mockResult, tableThreshold = 0, adapter = (0, frameworkAdapter_1.createAdapter)("jest"), snapshotForComplexTypes = false) {
     const lines = [];
+    const isAbstract = methods[0]?.isAbstractClass ?? false;
+    const abstractMethods = methods[0]?.abstractMethods ?? [];
+    const testClassName = isAbstract ? `Test${className}` : className;
+    // For abstract classes, generate a concrete test subclass
+    if (isAbstract) {
+        lines.push(`// Concrete subclass to test protected methods of abstract ${className}`);
+        lines.push(`class ${testClassName} extends ${className} {`);
+        // Stub all abstract methods with minimal implementations
+        for (const am of abstractMethods) {
+            const paramList = am.params.map(p => `_${p.name}: ${p.type}`).join(", ");
+            const returnDefault = buildAbstractMethodDefault(am.returnType, am.isAsync);
+            if (am.isAsync) {
+                lines.push(`  async ${am.name}(${paramList}): ${am.returnType} { return ${returnDefault}; }`);
+            }
+            else {
+                lines.push(`  ${am.name}(${paramList}): ${am.returnType} { return ${returnDefault}; }`);
+            }
+        }
+        // Expose protected methods via public wrappers
+        const protectedMethods = methods.filter(m => !m.isStatic && !abstractMethods.some(am => am.name === m.functionName));
+        for (const pm of protectedMethods) {
+            const paramList = pm.parameters.map(p => `${p.name}: ${p.type}`).join(", ");
+            const argList = pm.parameters.map(p => p.name).join(", ");
+            const retType = pm.returnType;
+            if (pm.isAsync) {
+                lines.push(`  async call${capitalize(pm.functionName)}(${paramList}): ${retType} { return this.${pm.functionName}(${argList}); }`);
+            }
+            else {
+                lines.push(`  call${capitalize(pm.functionName)}(${paramList}): ${retType} { return this.${pm.functionName}(${argList}); }`);
+            }
+        }
+        lines.push("}");
+        lines.push("");
+    }
     lines.push(`describe(${JSON.stringify(className)}, () => {`);
     // Determine if the class has any instance methods (non-static) before declaring `instance`
     const hasInstanceMethods = methods.some((m) => !m.isStatic);
     if (hasInstanceMethods) {
-        lines.push(`  let instance: ${className};`);
+        lines.push(`  let instance: ${testClassName};`);
     }
     // Generate mock objects for constructor dependencies
     // E-3: declare as `let` at describe scope, assign fresh instances in beforeEach
@@ -479,6 +532,14 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
             }
         }
     }
+    // For constructor-injected dependencies whose methods weren't found via
+    // the body-text dependency scan (because the class name doesn't appear in
+    // method bodies — only `this.<paramName>.method()` does), resolve the
+    // actual public methods from the injected class using ts-morph.
+    const sourceFilePath = methods[0]?.sourceFilePath;
+    if (sourceFilePath && ctorParams.length > 0) {
+        resolveCtorDepMethods(ctorParams, depMethodsByType, sourceFilePath);
+    }
     for (const param of ctorParams) {
         const mockName = `mock${capitalize(param.name)}`;
         letDeclarations.push(`  let ${mockName}: any;`);
@@ -494,8 +555,15 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
         }
         else {
             const fn = adapter.mockFn();
-            // Check if we have actual dependency metadata for this param's type
-            const knownMethods = depMethodsByType.get(param.type);
+            // Check if we have actual dependency metadata for this param's type.
+            // param.type may be a fully-qualified import path like
+            // import("../metadata-sync/metadata.repository").MetadataRepository
+            // so we also try matching by the short class name extracted from the end.
+            let knownMethods = depMethodsByType.get(param.type);
+            if (!knownMethods || knownMethods.size === 0) {
+                const shortType = param.type.replace(/^import\([^)]*\)\./, "").replace(/<.*>$/, "").trim();
+                knownMethods = depMethodsByType.get(shortType);
+            }
             if (knownMethods && knownMethods.size > 0) {
                 // Use actual method names from AST analysis
                 const mockProps = Array.from(knownMethods).map(m => {
@@ -510,7 +578,11 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
                 const typeLower = param.type.toLowerCase();
                 const asyncFn = `${fn}.mockResolvedValue(null)`;
                 const asyncIdFn = `${fn}.mockResolvedValue({ id: 1 })`;
-                if (typeLower.includes("repository") || typeLower.includes("repo")) {
+                if (typeLower.includes("configservice") || typeLower.includes("config_service")) {
+                    // NestJS ConfigService mock — must come before generic "service" match
+                    beforeEachAssignments.push(`    ${mockName} = { get: ${fn}.mockReturnValue('test'), getOrThrow: ${fn}.mockReturnValue('test') } as any;`);
+                }
+                else if (typeLower.includes("repository") || typeLower.includes("repo")) {
                     beforeEachAssignments.push(`    ${mockName} = { find: ${fn}.mockResolvedValue([]), findOne: ${asyncFn}, findById: ${asyncFn}, ` +
                         `save: ${asyncIdFn}, create: ${asyncIdFn}, update: ${asyncIdFn}, delete: ${asyncIdFn}, ` +
                         `createQueryBuilder: ${fn}.mockReturnValue({ where: ${fn}.mockReturnThis(), getOne: ${asyncFn}, getMany: ${fn}.mockResolvedValue([]) }) } as any;`);
@@ -529,13 +601,8 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
                     beforeEachAssignments.push(`    ${mockName} = { send: ${asyncFn}, emit: ${fn}, publish: ${asyncFn}, add: ${asyncFn} } as any;`);
                 }
                 else if (typeLower.includes("database") || typeLower.includes("nodepgdatabase") || typeLower.includes("drizzle") || typeLower.includes("pgtransaction")) {
-                    // Drizzle ORM database/transaction mock with chainable query builder
-                    const chain = `${fn}.mockReturnThis()`;
-                    beforeEachAssignments.push(`    ${mockName} = { select: ${fn}.mockReturnValue({ from: ${chain}, where: ${chain}, leftJoin: ${chain}, orderBy: ${chain}, limit: ${chain}, then: ${fn}.mockResolvedValue([]) }),` +
-                        ` insert: ${fn}.mockReturnValue({ values: ${fn}.mockReturnValue({ onConflictDoNothing: ${fn}.mockReturnValue({ returning: ${fn}.mockResolvedValue([{ id: 1 }]) }), returning: ${fn}.mockResolvedValue([{ id: 1 }]) }) }),` +
-                        ` update: ${fn}.mockReturnValue({ set: ${fn}.mockReturnValue({ where: ${fn}.mockReturnValue({ returning: ${fn}.mockResolvedValue([{ id: 1 }]) }) }) }),` +
-                        ` delete: ${fn}.mockReturnValue({ where: ${fn}.mockResolvedValue([]) }),` +
-                        ` execute: ${asyncFn}, query: ${asyncFn}, transaction: ${fn}.mockImplementation((cb: any) => cb(${mockName})) } as any;`);
+                    // Drizzle ORM database/transaction mock — Proxy-based self-referencing chain
+                    beforeEachAssignments.push(`    ${mockName} = new Proxy({} as any, { get: (_t, prop) => { if (prop === 'then' || prop === 'catch') return undefined; if (typeof prop === 'string' && !_t[prop]) { if (['select','insert','update','delete','execute','query'].includes(prop)) _t[prop] = ${fn}.mockImplementation(() => new Proxy({} as any, { get: (_c, m) => { if (m === 'then') return (cb: any) => Promise.resolve([]).then(cb); if (typeof m === 'string' && !_c[m]) _c[m] = ${fn}.mockReturnValue(_c); return _c[m]; } })); else if (prop === 'transaction') _t[prop] = ${fn}.mockImplementation((cb: any) => cb(${mockName})); else _t[prop] = ${fn}; } return _t[prop]; } });`);
                 }
                 else if (typeLower.includes("clickhouse") || typeLower.includes("client")) {
                     // ClickHouse / generic DB client mock
@@ -557,10 +624,24 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
             lines.push(decl);
         }
     }
+    // Collect env var properties from all methods (they share the same class)
+    const envVarProps = methods[0]?.envVarProperties ?? [];
+    if (envVarProps.length > 0) {
+        lines.push("");
+        lines.push("  let originalEnv: NodeJS.ProcessEnv;");
+    }
     lines.push("");
     lines.push("  beforeEach(() => {");
     // FA-2: clearAllMocks in beforeEach (keeps implementations, clears call history)
     lines.push(`    ${adapter.clearAllMocks()}`);
+    // Set up env vars before creating the instance (class properties read env at construction time)
+    if (envVarProps.length > 0) {
+        lines.push("    originalEnv = { ...process.env };");
+        for (const evp of envVarProps) {
+            const val = evp.defaultValue ?? "test-value";
+            lines.push(`    process.env['${evp.envVarName}'] = '${val}';`);
+        }
+    }
     // E-3: recreate fresh mock objects so mutations don't leak between tests
     for (const assignment of beforeEachAssignments) {
         lines.push(assignment);
@@ -570,10 +651,10 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
             const args = ctorParams
                 .map((p) => `mock${capitalize(p.name)}`)
                 .join(", ");
-            lines.push(`    instance = new ${className}(${args});`);
+            lines.push(`    instance = new ${testClassName}(${args});`);
         }
         else {
-            lines.push(`    instance = new ${className}();`);
+            lines.push(`    instance = new ${testClassName}();`);
         }
     }
     lines.push("  });");
@@ -581,8 +662,9 @@ function buildClassDescribe(className, methods, mockResult, tableThreshold = 0,
     lines.push("  afterEach(() => {");
     // FA-2: resetAllMocks in afterEach (resets implementations too)
     lines.push(`    ${adapter.resetAllMocks()}`);
-    // T-3: TODO for module-level singleton/cache reset
-    lines.push("    // TODO: reset any module-level singletons or caches if the SUT uses them");
+    if (envVarProps.length > 0) {
+        lines.push("    process.env = originalEnv;");
+    }
     lines.push("  });");
     // T-2: always emit afterAll (not only when ctorParams.length > 0)
     lines.push("");
@@ -650,7 +732,8 @@ function buildFunctionDescribe(fn, mockResult, tableThreshold = 0, adapter = (0,
         lines.push("  });");
         lines.push("");
     }
-    const constName = mockResult?.constantNames.get(fn.functionName);
+    const mockKey = fn.className ? `${fn.className}_${fn.functionName}` : fn.functionName;
+    const constName = mockResult?.constantNames.get(mockKey);
     const { tableCases, individualCases } = partitionCases(fn.cases, fn.parameters.length, tableThreshold);
     if (tableCases.length > 0) {
         lines.push(indentBlock(buildTableBlock(fn, tableCases, snapshotForComplexTypes), 1));
@@ -668,7 +751,8 @@ function buildMethodDescribe(fn, mockResult, tableThreshold = 0, adapter = (0, f
     const lines = [];
     lines.push(`// @testgen-sig:${buildSignatureFingerprint(fn)}`);
     lines.push(`describe(${JSON.stringify(fn.functionName)}, () => {`);
-    const constName = mockResult?.constantNames.get(fn.functionName);
+    const mockKey = fn.className ? `${fn.className}_${fn.functionName}` : fn.functionName;
+    const constName = mockResult?.constantNames.get(mockKey);
     const { tableCases, individualCases } = partitionCases(fn.cases, fn.parameters.length, tableThreshold);
     if (tableCases.length > 0) {
         lines.push(indentBlock(buildTableBlock(fn, tableCases, snapshotForComplexTypes), 1));
@@ -728,7 +812,7 @@ function buildTableBlock(scenario, tableCases, snapshotForComplexTypes = false)
     const isStatic = !!scenario.isStatic;
     const caller = isStatic
         ? `${scenario.className}.${fnName}`
-        : isMethod ? `instance.${fnName}` : fnName;
+        : isMethod ? `instance.${scenario.isAbstractClass ? `call${capitalize(fnName)}` : fnName}` : fnName;
     const safeParamNames = paramNames.map(safeName);
     if (isAsync) {
         lines.push(`  const result = await ${caller}(${safeParamNames.join(", ")});`);
@@ -752,7 +836,7 @@ function buildTestBlock(scenario, testCase, mockConstName, adapter = (0, framewo
         case "throws":
             return buildThrowsBlock(scenario, testCase, mockConstName);
         case "rejects":
-            return buildRejectsBlock(scenario, testCase, mockConstName);
+            return buildRejectsBlock(scenario, testCase, mockConstName, adapter);
         default:
             return buildStandardBlock(scenario, testCase, mockConstName, adapter, snapshotForComplexTypes);
     }
@@ -820,7 +904,7 @@ function buildStandardBlock(scenario, testCase, mockConstName, adapter = (0, fra
     const argsStr = testCase.paramNames.map(n => `${safeName(n)} as any`).join(", ");
     const caller = isStatic
         ? `${scenario.className}.${fnName}`
-        : isMethod ? `instance.${fnName}` : fnName;
+        : isMethod ? `instance.${scenario.isAbstractClass ? `call${capitalize(fnName)}` : fnName}` : fnName;
     const callExpr = `${caller}(${argsStr})`;
     if (isAsync) {
         lines.push(`  const result = await ${callExpr};`);
@@ -832,6 +916,7 @@ function buildStandardBlock(scenario, testCase, mockConstName, adapter = (0, fra
     lines.push("");
     // ── Assert ──────────────────────────────────────────────────────
     lines.push("  // Assert");
+    const assertStartIdx = lines.length;
     if (isDependencyTest) {
         // Verify only functions that the analyzer confirmed are called (have meta)
         // This avoids asserting on imports the function never uses
@@ -882,23 +967,57 @@ function buildStandardBlock(scenario, testCase, mockConstName, adapter = (0, fra
         for (const e of expectLines) {
             lines.push(`  ${e}`);
         }
-        // Improvement 3: add a commented dep-call verification tip for non-dep tests
+        // Add dependency-call verification for happy-path (valid input) tests
         if (!isDependencyTest && scenario.dependencies.length > 0) {
-            const firstDep = scenario.dependencies[0];
-            // Derive a mock variable name from the module path (e.g. "dashboard.service" → "mockDashboardService")
-            const lastSegment = firstDep.modulePath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "dependency";
-            const mockVarName = "mock" + lastSegment
-                .split(/[-_.]/)
-                .map(s => s.charAt(0).toUpperCase() + s.slice(1))
-                .join("");
-            // Pick the first known method name, or fall back to a generic placeholder
-            const methodName = firstDep.importedFunctionMeta[0]?.name
-                ?? firstDep.importedNames.find(n => n !== "default")
-                ?? "method";
-            lines.push("");
-            lines.push(`  // Tip: verify a specific dependency was invoked:`);
-            lines.push(`  // expect(${mockVarName}.${methodName}).toHaveBeenCalledTimes(1);`);
-            lines.push(`  // expect(${mockVarName}.${methodName}).toHaveBeenCalledWith(expect.objectContaining({ ... }));`);
+            const isHappyPath = testCase.label.includes("valid") || testCase.label.includes("typical");
+            const isClassMethod = !!scenario.className;
+            const ctorParams = scenario.constructorParams ?? [];
+            if (isHappyPath) {
+                lines.push("");
+                for (const dep of scenario.dependencies) {
+                    let mockPrefix = "";
+                    let skipDep = false;
+                    if (isClassMethod && ctorParams.length > 0) {
+                        const depTypeName = dep.importedNames.find(n => /^[A-Z]/.test(n)) ?? dep.localName;
+                        const matchingParam = ctorParams.find((p) => p.type === depTypeName || p.type.includes(depTypeName));
+                        if (matchingParam) {
+                            mockPrefix = `mock${capitalize(matchingParam.name)}.`;
+                        }
+                        else {
+                            skipDep = true;
+                        }
+                    }
+                    if (skipDep)
+                        continue;
+                    const metaList = dep.importedFunctionMeta.length > 0
+                        ? dep.importedFunctionMeta
+                        : dep.importedNames
+                            .filter(n => n !== "default" && !/^[A-Z]/.test(n))
+                            .map(n => ({ name: n, returnType: "unknown", isAsync: false, params: [] }));
+                    for (const meta of metaList) {
+                        if (isClassMethod && /^[A-Z]/.test(meta.name) && dep.importedFunctionMeta.length === 0)
+                            continue;
+                        const expectTarget = `${mockPrefix}${meta.name}`;
+                        const depParams = meta.params ?? [];
+                        if (depParams.length > 0) {
+                            const callWithArgs = buildCalledWithArgs(depParams, testCase.paramNames, testCase.argLiterals);
+                            lines.push(`  expect(${expectTarget}).toHaveBeenCalledWith(${callWithArgs});`);
+                        }
+                        else {
+                            lines.push(`  expect(${expectTarget}).toHaveBeenCalled();`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Fallback: if no assertions were generated, add a meaningful default
+    if (lines.length === assertStartIdx) {
+        if (isAsync) {
+            lines.push("  expect(result).toBeUndefined();");
+        }
+        else {
+            lines.push("  expect(result).toBeDefined();");
         }
     }
     lines.push("});");
@@ -935,22 +1054,66 @@ function buildThrowsBlock(scenario, testCase, mockConstName) {
     const argsStr = testCase.paramNames.map(n => `${safeName(n)} as any`).join(", ");
     const caller = isStatic
         ? `${scenario.className}.${fnName}`
-        : isMethod ? `instance.${fnName}` : fnName;
-    lines.push(`  expect(() => ${caller}(${argsStr})).toThrow(Error);`);
-    lines.push(`  // TODO: narrow to a specific error type, e.g. .toThrow(ValidationError) or .toThrow('message')`);
+        : isMethod ? `instance.${scenario.isAbstractClass ? `call${capitalize(fnName)}` : fnName}` : fnName;
+    // Use specific exception type from scenario label (e.g. "throws BadRequestException")
+    const throwsExType = extractExceptionFromLabel(testCase.label, "throws");
+    const errorMatcher = throwsExType || "Error";
+    lines.push(`  expect(() => ${caller}(${argsStr})).toThrow(${errorMatcher});`);
     lines.push("});");
     return lines.join("\n");
 }
 // ─── Rejects test block (async rejection) ────────────────────────────────────
-function buildRejectsBlock(scenario, testCase, mockConstName) {
+function buildRejectsBlock(scenario, testCase, mockConstName, adapter = (0, frameworkAdapter_1.createAdapter)("jest")) {
     const lines = [];
     const fnName = scenario.functionName;
     const isMethod = !!scenario.className;
     const isStatic = !!scenario.isStatic;
+    const isDepFailure = testCase.label === "propagates error when dependency fails";
     lines.push(`test(${JSON.stringify(testCase.label)}, async () => {`);
     // ── Arrange ──────────────────────────────────────────────────────
     const caseKey = camelCase(testCase.label);
-    if (testCase.paramNames.length > 0 && mockConstName) {
+    if (isDepFailure && scenario.dependencies.length > 0) {
+        // Set up a dependency to reject, triggering the error path
+        lines.push("  // Arrange — force a dependency to reject");
+        const isClassMethod = !!scenario.className;
+        const ctorParams = scenario.constructorParams ?? [];
+        // Find the first async dependency to make it fail
+        let arranged = false;
+        for (const dep of scenario.dependencies) {
+            if (arranged)
+                break;
+            let mockPrefix = "";
+            if (isClassMethod && ctorParams.length > 0) {
+                const depTypeName = dep.importedNames.find(n => /^[A-Z]/.test(n)) ?? dep.localName;
+                const matchingParam = ctorParams.find((p) => p.type === depTypeName || p.type.includes(depTypeName));
+                if (matchingParam) {
+                    mockPrefix = `mock${capitalize(matchingParam.name)}.`;
+                }
+                else {
+                    continue;
+                }
+            }
+            for (const meta of dep.importedFunctionMeta) {
+                if (meta.isAsync) {
+                    lines.push(`  const depError = new Error('dependency failure');`);
+                    lines.push(`  ${mockPrefix}${meta.name}.mockRejectedValueOnce(depError);`);
+                    arranged = true;
+                    break;
+                }
+            }
+        }
+        if (!arranged) {
+            lines.push(`  // No async dependency found — add a mockRejectedValueOnce call for the relevant dep`);
+        }
+        // Declare input params
+        if (testCase.paramNames.length > 0 && testCase.argLiterals.length > 0) {
+            for (let i = 0; i < testCase.paramNames.length; i++) {
+                lines.push(`  const ${safeName(testCase.paramNames[i])} = ${testCase.argLiterals[i] ?? "undefined"};`);
+            }
+        }
+        lines.push("");
+    }
+    else if (testCase.paramNames.length > 0 && mockConstName) {
         lines.push("  // Arrange");
         const mockRef = `mocks.${mockConstName}.${caseKey}`;
         for (const name of testCase.paramNames) {
@@ -972,12 +1135,35 @@ function buildRejectsBlock(scenario, testCase, mockConstName) {
     const argsStr = testCase.paramNames.map(n => `${safeName(n)} as any`).join(", ");
     const caller = isStatic
         ? `${scenario.className}.${fnName}`
-        : isMethod ? `instance.${fnName}` : fnName;
-    lines.push(`  await expect(${caller}(${argsStr})).rejects.toThrow();`);
-    lines.push(`  // TODO: narrow rejection, e.g. .rejects.toThrow(SpecificError) or .rejects.toThrow('message')`);
+        : isMethod ? `instance.${scenario.isAbstractClass ? `call${capitalize(fnName)}` : fnName}` : fnName;
+    // Use specific exception type from scenario label (e.g. "rejects with NotFoundException")
+    const rejectsExType = extractExceptionFromLabel(testCase.label, "rejects with");
+    if (isDepFailure) {
+        lines.push(`  await expect(${caller}(${argsStr})).rejects.toThrow('dependency failure');`);
+    }
+    else if (rejectsExType) {
+        lines.push(`  await expect(${caller}(${argsStr})).rejects.toThrow(${rejectsExType});`);
+    }
+    else {
+        lines.push(`  await expect(${caller}(${argsStr})).rejects.toThrow();`);
+    }
     lines.push("});");
     return lines.join("\n");
 }
+/**
+ * Extract an exception class name from a scenario label.
+ * e.g. "throws BadRequestException" → "BadRequestException"
+ *      "rejects with NotFoundException" → "NotFoundException"
+ */
+function extractExceptionFromLabel(label, prefix) {
+    if (!label.startsWith(prefix))
+        return null;
+    const rest = label.slice(prefix.length).trim();
+    // Must be a PascalCase identifier (exception class name)
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(rest))
+        return rest;
+    return null;
+}
 // ─── Mock return value builder ────────────────────────────────────────────────
 /**
  * Given a ts-morph return type string (e.g. "Promise<User>" or "string[]"),
@@ -1012,6 +1198,27 @@ function buildMockReturnValue(returnType) {
     // Object / interface / class type — generate a minimal shape
     return "{ id: 1 }";
 }
+/**
+ * Generate a minimal default return value for abstract method stubs.
+ * Used when generating concrete subclasses for abstract class testing.
+ */
+function buildAbstractMethodDefault(returnType, isAsync) {
+    const raw = returnType.trim();
+    // Unwrap Promise<T> for async methods
+    const promiseMatch = raw.match(/^Promise<(.+)>$/i);
+    const inner = (promiseMatch ? promiseMatch[1] : raw).trim().toLowerCase();
+    if (inner === "void" || inner === "undefined")
+        return isAsync ? "undefined as any" : "undefined as any";
+    if (inner === "boolean")
+        return "true";
+    if (inner === "number")
+        return "0";
+    if (inner === "string")
+        return "''";
+    if (inner.endsWith("[]") || inner.startsWith("array<"))
+        return "[] as any";
+    return "{} as any";
+}
 // ─── Expect stubs based on return type ───────────────────────────────────────
 /** Primitive/built-in type names that do NOT warrant snapshot assertions. */
 const SNAPSHOT_SKIP_TYPES = new Set([
@@ -1032,52 +1239,67 @@ function buildExpectStubs(returnType, scenarioLabel, snapshotForComplexTypes = f
     const t = returnType.trim().toLowerCase();
     const unwrapped = unwrapType(t);
     const stubs = [];
-    stubs.push("expect(result).toBeDefined();");
+    // Detect nullable return types (T | null) — guard/empty-input scenarios should expect null
+    const isNullable = unwrapped.includes("| null") || unwrapped.includes("null |");
+    const isGuardCase = scenarioLabel.includes("invalid") || scenarioLabel.includes("empty") || scenarioLabel.includes("guard") || scenarioLabel.includes("is 0");
+    if (isNullable && isGuardCase) {
+        stubs.push("expect(result).toBeNull();");
+        return stubs;
+    }
+    // Handle null / void / undefined early — no mock return value needed
+    if (unwrapped === "null") {
+        stubs.push("expect(result).toBeNull();");
+        return stubs;
+    }
+    if (unwrapped === "void" || unwrapped === "undefined") {
+        stubs.push("expect(result).toBeUndefined();");
+        return stubs;
+    }
+    // Derive the concrete expected value from the return type (mirrors mockReturnValue / mockResolvedValue)
+    const expectedValue = buildMockReturnValue(returnType);
     if (unwrapped === "number") {
-        stubs.push("expect(typeof result).toBe('number');");
-        if (scenarioLabel.includes("negative"))
-            stubs.push("// expect(result).toBeLessThan(0);");
-        if (scenarioLabel.includes("zero"))
-            stubs.push("// expect(result).toBe(0);");
-        if (scenarioLabel.includes("boundary"))
-            stubs.push("expect(Number.isFinite(result)).toBe(true);");
-        stubs.push("// TODO: add domain assertion — e.g. expect(result).toBe(expectedValue)");
+        if (scenarioLabel.includes("negative")) {
+            stubs.push("expect(result).toBeLessThan(0);");
+        }
+        else if (scenarioLabel.includes("zero")) {
+            stubs.push("expect(result).toBe(0);");
+        }
+        else {
+            stubs.push(`expect(result).toBe(${expectedValue});`);
+        }
     }
     else if (unwrapped === "string") {
-        stubs.push("expect(typeof result).toBe('string');");
-        if (scenarioLabel.includes("empty"))
-            stubs.push("// expect(result).toBe('');");
-        if (scenarioLabel.includes("valid"))
-            stubs.push("expect(result.length).toBeGreaterThan(0);");
-        stubs.push("// TODO: add domain assertion — e.g. expect(result).toEqual(expectedString)");
+        if (scenarioLabel.includes("empty")) {
+            stubs.push("expect(result).toBe('');");
+        }
+        else {
+            stubs.push(`expect(result).toBe(${expectedValue});`);
+        }
     }
     else if (unwrapped === "boolean") {
-        stubs.push("expect(typeof result).toBe('boolean');");
-        if (scenarioLabel.includes("truthy"))
-            stubs.push("// expect(result).toBe(true);");
-        if (scenarioLabel.includes("falsy"))
-            stubs.push("// expect(result).toBe(false);");
-        stubs.push("// TODO: add domain assertion — e.g. expect(result).toBe(true)");
-    }
-    else if (unwrapped === "null") {
-        stubs.length = 0;
-        stubs.push("expect(result).toBeNull();");
-    }
-    else if (unwrapped === "void" || unwrapped === "undefined") {
-        stubs.length = 0;
-        stubs.push("expect(result).toBeUndefined();");
+        if (scenarioLabel.includes("truthy")) {
+            stubs.push("expect(result).toBe(true);");
+        }
+        else if (scenarioLabel.includes("falsy")) {
+            stubs.push("expect(result).toBe(false);");
+        }
+        else {
+            stubs.push(`expect(result).toBe(${expectedValue});`);
+        }
     }
     else if (unwrapped.endsWith("[]") || unwrapped.startsWith("array<")) {
         stubs.push("expect(Array.isArray(result)).toBe(true);");
-        if (scenarioLabel.includes("empty"))
-            stubs.push("// expect(result).toHaveLength(0);");
-        stubs.push("// TODO: add domain assertion — e.g. expect(result).toHaveLength(n) or toContainEqual(item)");
+        if (scenarioLabel.includes("empty")) {
+            stubs.push("expect(result).toHaveLength(0);");
+        }
+        stubs.push(`expect(result).toEqual(${expectedValue});`);
     }
     else if (/ApiResponseDto/i.test(returnType)) {
         // Controller methods wrapped in ApiResponseDto<T>
-        stubs.push("expect(result).toHaveProperty('success');");
-        stubs.push("expect(result).toHaveProperty('data');");
-        stubs.push("// TODO: assert result.success === true and inspect result.data shape");
+        stubs.push("expect(result).toEqual(expect.objectContaining({");
+        stubs.push("  success: expect.any(Boolean),");
+        stubs.push("  data: expect.anything(),");
+        stubs.push("}));");
     }
     else {
         // Try to parse as an inline object type: { id: string; status: string; ... }
@@ -1088,14 +1310,9 @@ function buildExpectStubs(returnType, scenarioLabel, snapshotForComplexTypes = f
                 stubs.push(`  ${prop.name}: ${tsTypeToJestMatcher(prop.tsType)},`);
             }
             stubs.push("});");
-            stubs.push("// TODO: assert exact values, e.g. expect(result.id).toBe(expectedId)");
         }
         else {
-            stubs.push("expect(result).not.toBeNull();");
-            if (snapshotForComplexTypes && isComplexReturnType(unwrapped)) {
-                stubs.push("expect(result).toMatchSnapshot(); // Update snapshot after first run");
-            }
-            stubs.push("// TODO: add domain assertion — e.g. expect(result).toEqual(expected) or toHaveProperty('key', value)");
+            stubs.push(`expect(result).toEqual(${expectedValue});`);
         }
     }
     return stubs;
@@ -1245,6 +1462,9 @@ function computeRelativeImport(targetFilePath, fromFilePath) {
     if (!rel.startsWith("."))
         rel = "./" + rel;
     const basename = path.basename(targetFilePath, ".ts");
+    // Avoid double-slash when same directory (rel === "./")
+    if (rel === ".")
+        return `./${basename}`;
     return `${rel}/${basename}`;
 }
 // ─── Utility helpers ─────────────────────────────────────────────────────────
@@ -1271,4 +1491,137 @@ function safeName(name) {
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+// ─── Constructor dependency resolution ───────────────────────────────────────
+/** Names to skip when resolving class methods — lifecycle hooks, internals, built-in prototypes */
+const SKIP_METHOD_NAMES = new Set([
+    // Object prototype
+    "constructor", "toString", "valueOf", "hasOwnProperty",
+    "isPrototypeOf", "propertyIsEnumerable", "toLocaleString",
+    // NestJS lifecycle hooks
+    "onModuleInit", "onModuleDestroy", "onApplicationBootstrap",
+    "onApplicationShutdown", "beforeApplicationShutdown",
+    // String prototype methods
+    "charAt", "charCodeAt", "codePointAt", "concat", "indexOf",
+    "lastIndexOf", "localeCompare", "match", "matchAll", "replace",
+    "replaceAll", "search", "slice", "split", "substring", "substr",
+    "toLowerCase", "toLocaleLowerCase", "toUpperCase", "toLocaleUpperCase",
+    "trim", "trimStart", "trimEnd", "trimLeft", "trimRight",
+    "padStart", "padEnd", "repeat", "normalize", "includes",
+    "startsWith", "endsWith", "at", "anchor", "big", "blink",
+    "bold", "fixed", "fontcolor", "fontsize", "italics", "link",
+    "small", "strike", "sub", "sup",
+    // Array prototype methods
+    "push", "pop", "shift", "unshift", "splice", "sort", "reverse",
+    "map", "filter", "reduce", "reduceRight", "forEach", "some",
+    "every", "find", "findIndex", "findLast", "findLastIndex",
+    "flat", "flatMap", "fill", "copyWithin", "entries", "keys",
+    "values", "join",
+    // Number / Symbol / common built-ins
+    "toFixed", "toPrecision", "toExponential",
+    "length", "size",
+]);
+/**
+ * For constructor-injected dependencies, resolve their actual public method
+ * signatures by reading the dependency class via ts-morph. This fills in
+ * `depMethodsByType` for params whose methods weren't found through the
+ * body-text dependency scan (which misses `this.<param>.method()` patterns).
+ */
+function resolveCtorDepMethods(ctorParams, depMethodsByType, sourceFilePath) {
+    // Lazily create a ts-morph project only if needed
+    let project = null;
+    for (const param of ctorParams) {
+        // Extract short type name from potentially fully-qualified type
+        const shortType = param.type
+            .replace(/^import\([^)]*\)\./, "")
+            .replace(/<.*>$/, "")
+            .trim();
+        // Skip if we already have methods for this type (from dependency scan)
+        if (depMethodsByType.has(shortType) && depMethodsByType.get(shortType).size > 0)
+            continue;
+        if (depMethodsByType.has(param.type) && depMethodsByType.get(param.type).size > 0)
+            continue;
+        // Skip primitives, built-in types, and ORM/logger patterns (handled elsewhere)
+        const lower = shortType.toLowerCase();
+        if (/^(string|number|boolean|void|any|never|unknown|undefined|null|object)$/.test(lower))
+            continue;
+        if (/nodepgdatabase|pgtransaction|drizzle|logger|configservice|eventemitter/i.test(lower))
+            continue;
+        try {
+            if (!project) {
+                const tsConfig = findTsConfig(sourceFilePath);
+                project = new ts_morph_1.Project({ tsConfigFilePath: tsConfig });
+            }
+            // Find the source file of the dependency by resolving the import.
+            // Normalize path separators — ts-morph uses forward slashes internally.
+            const normalizedPath = sourceFilePath.replace(/\\/g, "/");
+            let sourceFile = project.getSourceFile(normalizedPath);
+            if (!sourceFile) {
+                sourceFile = project.getSourceFile(sourceFilePath);
+            }
+            if (!sourceFile) {
+                // If still not found, try adding it explicitly
+                try {
+                    sourceFile = project.addSourceFileAtPath(sourceFilePath);
+                }
+                catch { /* ignore */ }
+            }
+            if (!sourceFile)
+                continue;
+            // Look for the import declaration that brings in this type
+            const ctorImportDecl = sourceFile.getImportDeclarations().find(decl => {
+                const namedImps = decl.getNamedImports();
+                return namedImps.some(ni => ni.getName() === shortType);
+            });
+            if (!ctorImportDecl)
+                continue;
+            const ctorNamedImport = ctorImportDecl.getNamedImports().find(ni => ni.getName() === shortType);
+            if (!ctorNamedImport)
+                continue;
+            let type = ctorNamedImport.getNameNode().getType();
+            // If the type is `typeof ClassName` (the constructor), get the instance type
+            // by looking at the construct signature's return type.
+            const constructSigs = type.getConstructSignatures();
+            if (constructSigs.length > 0) {
+                type = constructSigs[0].getReturnType();
+            }
+            const props = type.getProperties();
+            const methodSet = new Set();
+            for (const prop of props) {
+                const methodName = prop.getName();
+                if (methodName.startsWith("_") || methodName.startsWith("#"))
+                    continue;
+                if (SKIP_METHOD_NAMES.has(methodName))
+                    continue;
+                const propType = prop.getTypeAtLocation(ctorNamedImport);
+                const callSigs = propType.getCallSignatures();
+                if (callSigs.length === 0)
+                    continue;
+                const sig = callSigs[0];
+                const returnTypeText = sig.getReturnType().getText();
+                const isAsync = /^Promise</i.test(returnTypeText);
+                methodSet.add({ name: methodName, isAsync });
+            }
+            if (methodSet.size > 0) {
+                depMethodsByType.set(shortType, methodSet);
+            }
+        }
+        catch {
+            // Silently continue — AST resolution can fail for external deps
+        }
+    }
+}
+/**
+ * Walk up from sourceFilePath to find the nearest tsconfig.json.
+ */
+function findTsConfig(sourceFilePath) {
+    let dir = path.dirname(sourceFilePath);
+    while (dir !== path.dirname(dir)) {
+        const candidate = path.join(dir, "tsconfig.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+        dir = path.dirname(dir);
+    }
+    // Fallback — let ts-morph use its own defaults
+    return path.join(path.dirname(sourceFilePath), "tsconfig.json");
+}
 //# sourceMappingURL=generator.js.map