Unit Test Strategies and Generation

You ask the AI to “write unit tests for UserService” and it generates 40 tests. They all pass. Coverage is 95%. You feel good until a customer reports that users with plus signs in their email addresses cannot register. None of those 40 tests covered that case because the AI tested the happy path in 40 slightly different ways. Volume is not coverage. The right tests at the right boundaries catch bugs — and that requires specific, intentional prompting.

What You’ll Walk Away With

• Prompt patterns that generate tests focused on behavior and edge cases, not just line coverage
• Mocking strategies that keep tests fast and reliable without over-mocking
• Techniques for testing error handling, concurrency, and boundary conditions
• Workflows for maintaining tests as code evolves
• Mutation testing integration to verify your tests actually catch bugs

The Behavior-First Approach

The most effective AI-generated tests describe what the code should do, not how it does it internally.

Cursor

Open the file to test and use Agent mode:

@src/services/order.service.ts
Generate unit tests for OrderService.calculateTotal. Focus on BEHAVIOR:

1. "should apply percentage discount correctly" (10% off $100 = $90)
2. "should apply fixed discount correctly" ($15 off $100 = $85)
3. "should not allow total below zero" (discount > subtotal)
4. "should calculate tax after discount" (tax on discounted amount, not original)
5. "should handle empty cart" (zero items, no discount)
6. "should round to 2 decimal places" (avoid floating point weirdness)
7. "should reject negative quantities" (throw ValidationError)
8. "should handle mixed currency items" (throw CurrencyMismatchError)

Test through the public API only. Do not mock internal methods.
Mock only the database and external service dependencies.
Follow patterns in @src/services/__tests__/payment.service.test.ts

Claude Code

claude "Read /src/services/order.service.ts and generate behavior-focused unit tests.

For calculateTotal, test these behaviors:
1. Percentage discounts applied correctly
2. Fixed-amount discounts applied correctly
3. Total never goes below zero
4. Tax calculated on discounted amount
5. Empty cart handling
6. Floating point precision (round to 2 decimals)
7. Negative quantity rejection
8. Mixed currency rejection

Mock ONLY: OrderRepository, TaxService, DiscountService
Do NOT mock: internal methods, utility functions
Use Jest + TypeScript. Save to /src/services/__tests__/order.service.test.ts
Run the tests after generating them. Fix any failures."

Codex

Generate behavior-driven unit tests for OrderService.calculateTotal.

Test each business rule independently:
- Discount application (percentage and fixed)
- Tax calculation timing (after discount)
- Boundary conditions (empty cart, zero total, max values)
- Error conditions (negative quantities, currency mismatch)
- Precision handling (floating point rounding)

Follow existing test conventions in the project.
Run the test suite after generating. Fix any issues.
Create a PR with the new tests.

Intelligent Mocking Strategies

The Boundary Rule: Mock at the Boundary, Not Internally

Caution

A common mistake with AI-generated tests is over-mocking. If you mock everything, your tests prove nothing. If you mock nothing, your tests are slow and brittle. The rule: mock at service boundaries (databases, APIs, file systems) and test everything inside those boundaries as a unit.

Tip

Copy-paste prompt for proper mocking:

Generate tests for AuthService.login with these mocking rules:

MOCK these (external boundaries):
- UserRepository.findByEmail (database)
- BcryptService.compare (we trust bcrypt works - mock for speed)
- TokenService.generate (external signing service)

DO NOT MOCK these (internal logic under test):
- AuthService's internal validation logic
- Input sanitization
- Rate limiting logic
- Audit logging calls (verify these are called correctly)

For each mock, show both the "happy" setup and the "failure" setup.
Example: UserRepository.findByEmail should return a user object for success tests
and null for "user not found" tests and throw for "database down" tests.

Test Data Factories

Stop hardcoding test data. Use factories that generate realistic data with overridable defaults.

Tip

Copy-paste prompt for test factories:

Create a test data factory for our User entity at /src/test/factories/user.factory.ts.

The User entity has: id (uuid), email (string), name (string), hashedPassword (string),
role (admin | user | moderator), status (active | suspended | pending),
createdAt (Date), lastLoginAt (Date | null), preferences (JSON object).

The factory should:
1. Use faker.js for realistic data generation
2. Have a build() method that returns a plain object (for unit tests)
3. Have a create() method that persists to the test database (for integration tests)
4. Support overrides: UserFactory.build({ role: 'admin' })
5. Support traits: UserFactory.build('suspended') for common configurations
6. Generate UNIQUE emails even when called in bulk
7. Have a buildList(count) method for generating arrays

Include these traits:
- 'admin': role=admin, status=active
- 'suspended': status=suspended, lastLoginAt=null
- 'newUser': createdAt within last 24 hours, lastLoginAt=null
- 'powerUser': role=moderator, lastLoginAt within last hour

Testing Error Handling

Error handling is where most AI-generated tests are weakest. Prompt specifically for error scenarios.

Tip

Copy-paste prompt for error handling tests:

Generate error handling tests for PaymentService.processPayment:

Test each failure mode independently:
1. Network timeout to payment provider (should retry 3 times, then throw TimeoutError)
2. Payment provider returns 402 (insufficient funds - should throw PaymentDeclinedError with reason)
3. Payment provider returns 500 (should retry once, then throw ProviderError)
4. Idempotency key already used (should return the original result, not retry)
5. Database fails when saving payment record (should NOT reverse the charge - log for manual review)
6. Invalid amount (zero, negative, > $10,000 - should throw ValidationError before calling provider)
7. Expired payment method (should throw PaymentMethodExpiredError with user-friendly message)

For each error test, verify:
- The correct error TYPE is thrown (not just any error)
- The error MESSAGE is specific and actionable
- Side effects are handled correctly (rollback, logging, notifications)
- The error is NOT swallowed silently

Concurrency Testing

AI tools can generate concurrency tests that most developers skip.

Tip

Copy-paste prompt for concurrency tests:

Generate concurrency tests for InventoryService.reserveStock:

1. Two requests for the same item arriving simultaneously:
   - Only one should succeed if stock = 1
   - Both should succeed if stock >= 2
   - Neither should result in negative stock

2. Reserve and cancel racing:
   - A reservation and its cancellation arriving at the same time
   - Final state should be consistent (either reserved or cancelled, not corrupted)

3. Bulk reservation:
   - 100 concurrent reservations for an item with stock = 50
   - Exactly 50 should succeed, 50 should fail
   - Total reserved should never exceed stock

Use Promise.all for simulating concurrency. Add timing assertions to detect
when operations are actually executing in parallel vs. being serialized.

Mutation Testing: Proving Your Tests Work

Coverage metrics lie. A test that executes a line does not necessarily verify its behavior. Mutation testing introduces small changes (mutations) to your code and checks if tests catch them.

1. Install Stryker Mutator

   npm install --save-dev @stryker-mutator/core @stryker-mutator/jest-runner @stryker-mutator/typescript-checker

2. Configure for your project

   npx stryker init
   # Select Jest runner, TypeScript checker
   # Set mutate to: src/services/**/*.ts (start small)

3. Run and analyze results

   npx stryker run
   # Review the HTML report - focus on surviving mutations

4. Use AI to kill surviving mutants

   Feed the surviving mutations back to the AI for targeted test generation.

Tip

Copy-paste prompt for killing surviving mutations:

Stryker mutation testing found these surviving mutations in OrderService.calculateTotal:

1. Line 42: Changed `total > 0` to `total >= 0` - SURVIVED (no test catches this)
2. Line 58: Changed `discount * 0.01` to `discount * 0.02` - SURVIVED
3. Line 71: Removed the `Math.round(total * 100) / 100` call - SURVIVED

For each surviving mutation, write a test that would FAIL if that mutation were applied:
1. A test where total is exactly 0 and the behavior should differ from positive
2. A test with a known discount percentage that verifies the exact output amount
3. A test where the calculation produces more than 2 decimal places and asserts rounding

These tests should be minimal - test exactly the mutation boundary, nothing more.

Test Maintenance

AI-Assisted Test Updates

When your implementation changes, AI can update the tests intelligently.

Tip

Copy-paste prompt for test maintenance:

I've refactored UserService.createUser to return a Result<User, CreateUserError>
instead of throwing exceptions. Update the test file at
/src/services/__tests__/user.service.test.ts:

1. Change all `expect(...).rejects.toThrow(...)` to check the error variant of Result
2. Change success assertions to check the success variant of Result
3. Keep the same test scenarios - only change how results are asserted
4. Do NOT add or remove tests - just update the assertion pattern
5. Run the tests after updating to verify they pass

Show me the diff of what changed so I can verify no test logic was altered.

When This Breaks

“AI generates tests that all look the same.” You gave a generic prompt. Be specific about the scenarios you want tested. List the edge cases, error conditions, and boundary values explicitly.

“Tests pass locally but fail in CI.” Check for test isolation issues. AI-generated tests sometimes share mutable state between tests. Ensure beforeEach resets all mocks and test state. Add --runInBand to CI if tests have hidden parallelism issues.

“Mutation score is low despite high coverage.” Your tests are executing code without verifying its output. Focus on adding assertions for return values, side effects, and error conditions. Coverage without assertions is meaningless.

“Test suite is slow after AI generated hundreds of tests.” Review for redundancy. Ask the AI: “Analyze these tests and identify sets that cover the same code paths. Which tests can be removed without reducing mutation coverage?”

What’s Next

Integration Testing Test service interactions and database operations with AI.

Test Data Management Factories, fixtures, and data generation for consistent testing.

E2E Testing Automate user journey testing from signup to checkout.