rt { DiscountValidator } from '../src/discounts/DiscountValidator'; import { ValidationError } from '../src/errors/ValidationError';

vi.mock('../src/repositories/CartRepository'); vi.mock('../src/pricing/PricingEngine'); vi.mock('../src/discounts/DiscountValidator');

describe('OrderValidationService', () => { let service: OrderValidationService; let mockCartRepo: jest.Mocked<CartRepository>; let mockPricing: jest.Mocked<PricingEngine>; let mockDiscount: jest.Mocked<DiscountValidator>;

beforeEach(() => { vi.clearAllMocks(); mockCartRepo = new CartRepository() as jest.Mocked<CartRepository>; mockPricing = new PricingEngine() as jest.Mocked<PricingEngine>; mockDiscount = new DiscountValidator() as jest.Mocked<DiscountValidator>; service = new OrderValidationService(mockCartRepo, mockPricing, mockDiscount); });

it('should reject validation when cart is empty', async () => { vi.mocked(mockCartRepo.getCart).mockResolvedValue([]); await expect(service.validateCart('user-123')).rejects.toThrow(ValidationError); });

it('should apply tiered discount when quantity exceeds threshold', async () => { const cart = [{ sku: 'PROD-001', quantity: 15, price: 20 }]; vi.mocked(mockCartRepo.getCart).mockResolvedValue(cart); vi.mocked(mockDiscount.calculateTieredDiscount).mockReturnValue(0.15); vi.mocked(mockPricing.applyDiscount).mockReturnValue(255);

const result = await service.validateCart('user-123');
expect(result.total).toBe(255);
expect(mockDiscount.calculateTieredDiscount).toHaveBeenCalledWith(15);

});

it('should throw ValidationError for malformed SKU format', async () => { const cart = [{ sku: 'INVALID', quantity: 1, price: 10 }]; vi.mocked(mockCartRepo.getCart).mockResolvedValue(cart); await expect(service.validateCart('user-123')).rejects.toThrow(/SKU format/); }); });

### Step 4: Implement Mutation Verification
Structural correctness does not equal behavioral verification. Introduce Stryker Mutator to validate that tests actually catch implementation defects.

**Rationale for Architecture Choices:**
- **Explicit mock contracts** prevent runtime failures caused by AI hallucinating method signatures.
- **Framework pinning** (Vitest/Jest/Pytest) in the prompt ensures syntax alignment and avoids cross-framework drift.
- **Mutation gating** replaces subjective code review with objective coverage validation. If a test passes after a comparison operator is flipped or a null check is removed, the assertion is structurally sound but behaviorally empty.
- **Batch prompt generation** conserves free-tier quotas by requesting complete suites in single passes rather than iterative line-by-line refinement.

## Pitfall Guide

### 1. Context Starvation
**Explanation:** The model generates tests without access to type definitions, dependency boundaries, or error contracts, resulting in tests that compile but fail during execution.
**Fix:** Always inject explicit interfaces, type aliases, and error class definitions in the prompt. Use TypeScript's `export type` or `interface` blocks to provide contract boundaries.

### 2. Mock Drift
**Explanation:** AI-generated mocks often omit required methods, return incorrect types, or fail to simulate async behavior, causing false positives.
**Fix:** Validate mock implementations against actual module exports. Use `vi.mocked()` or equivalent framework utilities to enforce type safety. Run tests in isolation before integrating into the suite.

### 3. False Coverage Confidence
**Explanation:** Tests pass against the original implementation but miss edge cases, creating a dangerous illusion of safety. This is the most common failure mode in AI-generated suites.
**Fix:** Implement mutation testing as a CI gate. Introduce intentional defects (flip comparisons, remove null checks, alter return values) and verify that tests fail. Tools like Stryker automate this process.

### 4. Quota Exhaustion
**Explanation:** Iterative refinement (fixing mocks, adjusting assertions, handling async boundaries) burns through free-tier limits before the suite reaches production readiness.
**Fix:** Structure prompts to request complete suites in single passes. Use batch generation templates. Reserve free-tier quotas for critical path validation rather than exploratory drafting.

### 5. Framework Syntax Drift
**Explanation:** AI outputs Jest syntax for Vitest projects, or Pytest fixtures for Mocha/Chai setups, causing configuration mismatches and CI failures.
**Fix:** Pin the target framework explicitly in every prompt. Add framework-specific linting rules to catch syntax drift early. Maintain a reference test file that the model can pattern-match against.

### 6. Over-Reliance on Single-Pass Generation
**Explanation:** Treating AI output as production-ready without human review leads to brittle tests, missing assertions, and unhandled async boundaries.
**Fix:** Treat AI as a draft generator. Enforce a review checklist: verify mock contracts, confirm assertion coverage, validate async/await patterns, and run mutation checks before merging.

### 7. Ignoring Async Boundaries
**Explanation:** AI frequently omits `await`, mishandles promise resolution, or fails to simulate timeout/race conditions, causing flaky tests.
**Fix:** Explicitly request async/await patterns, timeout handling, and race condition simulation in prompts. Use framework utilities like `waitFor` or `act` to stabilize async test execution.

## Production Bundle

### Action Checklist
- [ ] Define context injection template: Include target function, dependencies, type definitions, and framework specification.
- [ ] Select integration mode: Match inline completion, chat interface, or codebase indexing to your editor and workflow.
- [ ] Generate batch suites: Request complete test files in single passes to conserve free-tier quotas.
- [ ] Validate mock contracts: Ensure AI-generated mocks align with actual module exports and type signatures.
- [ ] Run mutation verification: Integrate Stryker or equivalent tool to confirm tests catch intentional defects.
- [ ] Pin framework syntax: Explicitly specify Vitest, Jest, or Pytest in prompts to prevent cross-framework drift.
- [ ] Enforce CI gates: Block merges if mutation score falls below threshold or if async boundaries are unhandled.

### Decision Matrix

| Scenario | Recommended Approach | Why | Cost Impact |
|----------|---------------------|-----|-------------|
| TypeScript project with existing test patterns | Codebase-aware editor (Cursor free tier) | Automatic pattern matching reduces prompt overhead and ensures style consistency | Low (monthly request limits) |
| Java/Python codebase with AWS dependencies | IDE plugin (Amazon Q Developer free tier) | Strong language optimization and AWS service alignment | Low (generous free tier) |
| Rapid one-off test generation for legacy modules | Web LLM (ChatGPT GPT-4o / Claude.ai free) | Large context window handles full module pasting and detailed reasoning | Medium (daily message limits) |
| Incremental test drafting during active development | Inline completion (GitHub Copilot free tier) | Low friction, fits naturally into coding flow | Low (monthly completion limits) |
| High-assurance production suites requiring verification | Mutation-gated pipeline (Stryker + any AI tool) | Objective validation replaces subjective review, catches false coverage | Low (open-source tooling) |

### Configuration Template
Ready-to-copy Stryker + Vitest configuration for mutation verification:

```typescript
// stryker.config.ts
import type { StrykerOptions } from '@stryker-mutator/core';
import { VitestTestRunner } from '@stryker-mutator/vitest-runner';

export const strykerConfig: StrykerOptions = {
  mutate: ['src/**/*.ts', '!src/**/*.d.ts'],
  testRunner: 'vitest',
  testRunnerNodeArgs: ['--experimental-vm-modules'],
  coverageAnalysis: 'perTest',
  thresholds: {
    high: 80,
    low: 60,
    break: 50
  },
  reporters: ['progress', 'clear-text', 'html'],
  htmlReporter: {
    baseDir: 'reports/mutation'
  },
  mutator: {
    plugins: []
  },
  ignoreStatic: true,
  ignoreLocations: [
    'src/**/*.d.ts',
    'src/**/*.test.ts',
    'src/**/*.spec.ts'
  ]
};

export default strykerConfig;

Quick Start Guide

1. Install dependencies: Run npm install --save-dev vitest @stryker-mutator/core @stryker-mutator/vitest-runner to set up the test runner and mutation engine.
2. Create context template: Define a reusable prompt structure that includes target functions, dependency interfaces, and framework specifications.
3. Generate initial suite: Use your chosen AI tool to produce a complete test file. Paste the context template and request framework-specific output.
4. Run mutation verification: Execute npx stryker run to validate that tests catch intentional defects. Adjust assertions if the mutation score falls below your threshold.
5. Integrate into CI: Add mutation verification as a required check in your pipeline. Block merges if coverage drops or if async boundaries remain unhandled.

By treating AI test generation as a structured pipeline rather than a prompt exercise, teams can achieve reliable coverage, minimize maintenance overhead, and maintain production confidence without exhausting free-tier resources. The tool generates the structure; the verification pipeline validates the behavior. Neither step is optional for engineering-grade test suites.