bash# Install Claude Code if you haven't
npm install -g @anthropic-ai/claude-code

# Open your project
cd your-project
claude

Write comprehensive unit tests for @src/utils/pricing.ts
Cover edge cases for negative quantities, zero prices, and currency conversion errors.
Use Vitest with the existing test patterns in @src/utils/__tests__/

pythonimport anthropic
import os

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def generate_tests_for_file(source_code: str, framework: str = "pytest") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"""Write comprehensive {framework} tests for this code.
Include:
- Happy path tests for all public functions
- Edge cases (empty inputs, boundary values, None/null)
- Error handling tests
- At least one parametrized test where appropriate

Source code:

Return only the test file content, no explanation."""
            }
        ]
    )
    return response.content[0].text

# Example usage
with open("src/services/payment.py") as f:
    source = f.read()

tests = generate_tests_for_file(source)

with open("tests/test_payment.py", "w") as f:
    f.write(tests)

python# src/auth/validators.py
from datetime import date
from typing import Optional
import re

class ValidationError(Exception):
    pass

def validate_registration(
    email: str,
    password: str,
    birth_date: Optional[str] = None
) -> dict:
    """Validate user registration fields."""
    errors = {}

    # Email validation
    email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}


Ask Claude: "Write pytest tests for this validate_registration function. I want 100% branch coverage."

Claude generates:

python# tests/test_validators.py
import pytest
from datetime import date, timedelta
from src.auth.validators import validate_registration, ValidationError


class TestEmailValidation:
    def test_valid_email_accepted(self):
        result = validate_registration("[email protected]", "SecurePass1")
        assert result["email"] == "[email protected]"

    def test_email_normalized_to_lowercase(self):
        result = validate_registration("[email protected]", "SecurePass1")
        assert result["email"] == "[email protected]"

    def test_email_missing_at_symbol_raises(self):
        with pytest.raises(ValidationError, match="email"):
            validate_registration("notanemail.com", "SecurePass1")

    def test_email_missing_domain_raises(self):
        with pytest.raises(ValidationError, match="email"):
            validate_registration("user@", "SecurePass1")

    def test_email_missing_tld_raises(self):
        with pytest.raises(ValidationError, match="email"):
            validate_registration("user@domain", "SecurePass1")

    @pytest.mark.parametrize("email", [
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ])
    def test_valid_email_formats(self, email):
        result = validate_registration(email, "SecurePass1")
        assert result["valid"] is True


class TestPasswordValidation:
    def test_valid_password_accepted(self):
        result = validate_registration("[email protected]", "SecurePass1")
        assert result["valid"] is True

    def test_short_password_raises(self):
        with pytest.raises(ValidationError, match="8 characters"):
            validate_registration("[email protected]", "Abc1")

    def test_password_without_uppercase_raises(self):
        with pytest.raises(ValidationError, match="uppercase"):
            validate_registration("[email protected]", "securepass1")

    def test_password_without_digit_raises(self):
        with pytest.raises(ValidationError, match="digit"):
            validate_registration("[email protected]", "SecurePassword")

    def test_exactly_8_chars_valid(self):
        result = validate_registration("[email protected]", "Secure1!")
        assert result["valid"] is True


class TestAgeValidation:
    def _age_to_birth_date(self, age: int) -> str:
        dob = date.today() - timedelta(days=age * 365)
        return dob.isoformat()

    def test_adult_user_accepted(self):
        result = validate_registration(
            "[email protected]", "SecurePass1",
            birth_date=self._age_to_birth_date(25)
        )
        assert result["valid"] is True

    def test_exactly_13_accepted(self):
        result = validate_registration(
            "[email protected]", "SecurePass1",
            birth_date=self._age_to_birth_date(13)
        )
        assert result["valid"] is True

    def test_under_13_raises(self):
        with pytest.raises(ValidationError, match="13 years"):
            validate_registration(
                "[email protected]", "SecurePass1",
                birth_date=self._age_to_birth_date(12)
            )

    def test_invalid_date_format_raises(self):
        with pytest.raises(ValidationError, match="Invalid date format"):
            validate_registration(
                "[email protected]", "SecurePass1",
                birth_date="12/25/2000"
            )

    def test_no_birth_date_skips_age_validation(self):
        result = validate_registration("[email protected]", "SecurePass1")
        assert result["valid"] is True


Notice what Claude did here:
Organized tests into logical classes by concern
Added a helper method for date math (reusable across tests)
Used parametrize for multiple valid email formats
Tested the exact boundary (age == 13) explicitly
Covered the None/missing birth_date path

This would take 30-45 minutes to write manually. With Claude it takes 2 minutes, and you get better coverage.

Writing Integration Tests with Claude: TypeScript/Node.js

Integration tests are harder because they involve multiple components, databases, or external services. Claude handles this well if you give it context about your stack.

Here's a prompt pattern that works:

Write Jest integration tests for this Express route handler:
@src/routes/orders.ts

Context:
- Uses Prisma ORM with PostgreSQL
- Auth middleware is already applied (req.user is always populated in tests)
- Use jest-mock-extended for Prisma mocking
- Follow the patterns in @src/routes/__tests__/users.test.ts

Test these scenarios:
1. Successful order creation with valid payload
2. Order creation fails with invalid product ID
3. Inventory check prevents order when out of stock
4. Rate limiting blocks after 10 requests/minute


Claude generates complete test files with proper mock setup, teardown, and realistic test data. The key is providing the framework context and pointing to existing test patterns — Claude matches your codebase style exactly.

For database integration tests (hitting a real test DB), use this pattern:

typescript// tests/integration/orders.test.ts
import { createTestDatabase, cleanupTestDatabase } from '../helpers/db'
import { app } from '../../src/app'
import request from 'supertest'

describe('Orders API', () => {
  let db: TestDatabase

  beforeAll(async () => {
    db = await createTestDatabase()
  })

  afterAll(async () => {
    await cleanupTestDatabase(db)
  })

  afterEach(async () => {
    await db.truncate(['orders', 'order_items'])
  })

  it('creates order and decrements inventory', async () => {
    const product = await db.seed.product({ stock: 5 })
    const user = await db.seed.user()

    const response = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${user.token}`)
      .send({ items: [{ productId: product.id, quantity: 2 }] })

    expect(response.status).toBe(201)
    expect(response.body.order.items).toHaveLength(1)

    const updatedProduct = await db.products.findById(product.id)
    expect(updatedProduct.stock).toBe(3) // 5 - 2
  })
})


Ask Claude to help you build the createTestDatabase helper — it's one of the most valuable pieces of your test infrastructure and Claude can scaffold it from a description of your schema.

E2E Testing with Claude + Playwright

End-to-end tests are where many teams give up because writing them by hand is tedious. Claude dramatically reduces this friction.

Step 1: Record the user flow in plain English, then ask Claude to write the test:

Write a Playwright test for this checkout flow:
1. User logs in with test credentials
2. Adds product "Blue Widget" to cart from the product listing page
3. Proceeds to checkout
4. Fills in shipping address (use test data)
5. Selects "Standard Shipping"
6. Completes payment with Stripe test card 4242 4242 4242 4242
7. Verifies order confirmation page shows correct total

The app runs on http://localhost:3000 in test mode.
Use the Page Object Model pattern.


Claude produces a full POM-structured Playwright test:

typescript// tests/e2e/checkout.spec.ts
import { test, expect } from '@playwright/test'
import { LoginPage } from './pages/LoginPage'
import { ProductListingPage } from './pages/ProductListingPage'
import { CartPage } from './pages/CartPage'
import { CheckoutPage } from './pages/CheckoutPage'
import { OrderConfirmationPage } from './pages/OrderConfirmationPage'

const TEST_USER = {
  email: '[email protected]',
  password: 'TestPassword123'
}

const TEST_ADDRESS = {
  street: '123 Test Street',
  city: 'San Francisco',
  state: 'CA',
  zip: '94105',
  country: 'US'
}

test.describe('Checkout Flow', () => {
  test('completes full purchase and shows order confirmation', async ({ page }) => {
    const loginPage = new LoginPage(page)
    const productListing = new ProductListingPage(page)
    const cart = new CartPage(page)
    const checkout = new CheckoutPage(page)
    const confirmation = new OrderConfirmationPage(page)

    // Login
    await loginPage.navigate()
    await loginPage.login(TEST_USER.email, TEST_USER.password)
    await expect(page).toHaveURL('/dashboard')

    // Add to cart
    await productListing.navigate()
    await productListing.addToCart('Blue Widget')
    await expect(page.getByTestId('cart-count')).toHaveText('1')

    // Checkout
    await cart.navigate()
    await cart.proceedToCheckout()

    await checkout.fillShippingAddress(TEST_ADDRESS)
    await checkout.selectShipping('Standard Shipping')
    await checkout.fillPaymentCard({
      number: '4242 4242 4242 4242',
      expiry: '12/28',
      cvc: '123'
    })
    await checkout.placeOrder()

    // Verify confirmation
    await expect(page).toHaveURL(/\/orders\/\w+\/confirmation/)
    await expect(confirmation.orderTotal).toBeVisible()
    await expect(confirmation.orderStatus).toHaveText('Confirmed')
  })
})


Step 2: Use Claude to generate the Page Object classes — paste the HTML for each page and ask Claude to extract the selectors and create the POM classes. This is the most tedious part of E2E setup and Claude handles it instantly.

Advanced Techniques: Getting More from Claude on Tests

Technique 1: Coverage-Driven Test Generation

Run your existing tests, get the coverage report, paste it to Claude:

Here's my current coverage report for src/payments/processor.ts:
[paste lcov output]

The following lines are uncovered: 45-67 (error retry logic), 89-92 (webhook validation).
Write tests specifically for these uncovered paths.


This is the fastest way to hit coverage targets.

Technique 2: Mutation Testing Collaboration

Use a mutation testing tool (Stryker for JS, mutmut for Python) to find weak tests, then ask Claude to fix them:

Stryker found these surviving mutants in my test suite:
- Line 34: changed '>' to '>=' — tests didn't catch it
- Line 67: removed null check — tests didn't catch it

Here's the source code and current tests. Write additional assertions that would kill these mutants.


Technique 3: Test Data Factories

Ask Claude to build realistic test data factories for your domain:

Create a factory module for generating test data for our e-commerce domain.
Entities: User, Product, Order, OrderItem, Address
Use faker.js
Include builder pattern with sensible defaults and overrides


The factory code Claude generates becomes shared infrastructure that makes all your tests easier to write.

Technique 4: Property-Based Testing

For complex business logic, ask Claude to write property-based tests using Hypothesis (Python) or fast-check (TypeScript):

pythonfrom hypothesis import given, strategies as st
from src.pricing import calculate_discount

@given(
    price=st.floats(min_value=0.01, max_value=10000.0),
    discount_pct=st.floats(min_value=0.0, max_value=100.0)
)
def test_discount_never_increases_price(price, discount_pct):
    discounted = calculate_discount(price, discount_pct)
    assert discounted <= price

@given(
    price=st.floats(min_value=0.01, max_value=10000.0)
)
def test_zero_discount_returns_original_price(price):
    assert calculate_discount(price, 0) == price


Claude generates the property strategies and invariants — you get hundreds of test cases for free.

Common Mistakes to Avoid

Don't paste the whole codebase. Focused context (one file, one function) produces better tests than dumping 3,000 lines at Claude. If a function has dependencies, describe them rather than including all source.

Don't accept mocks blindly. Claude sometimes over-mocks. If you see tests mocking the database, the HTTP client, and the logger, ask: "Which of these mocks are masking real behavior? What should be an integration test instead?"

Don't skip the review. AI-generated tests can have subtle issues — testing the mock instead of the real thing, asserting on implementation details rather than behavior, using incorrect test data assumptions. Read the generated tests before committing.

Do tell Claude your quality bar. "I want tests that would still pass if I refactored the internal implementation but kept the same public behavior" produces very different tests than "write tests for this function."

Key Takeaways

Claude cuts test-writing time by 60-80% for unit and integration tests — the real value is in edge case coverage you'd miss manually
Claude Code's file-context integration is the best DX for active development; the API works better for batch generation across many files
Property-based tests and mutation-testing-driven test improvement are underrated techniques where Claude adds significant leverage
Always review generated tests for over-mocking and implementation-coupled assertions
Build shared test infrastructure (factories, DB helpers) with Claude once and reuse everywhere

Next Steps

Ready to add AI to your testing workflow?

Start your Claude API free trial → — $5 free credits, enough to generate tests for an entire medium-sized codebase.

If you're preparing for the Claude Certified Architect (CCA) exam, testing patterns are a core topic in the agentic systems module. Practice with our CCA-F question bank at AI for Anything — 200+ questions covering tool use, multi-agent design, and error handling, all aligned to the real exam blueprint.

Also worth reading:
How to Use Claude for Code Review — catch issues before they reach tests
Claude Code Subagents for Parallel Development — run test generation and feature development in parallel
Claude for TypeScript Development — full guide to AI-assisted TypeScript work

    if not re.match(email_pattern, email):
        errors['email'] = 'Invalid email format'

    # Password validation
    if len(password) < 8:
        errors['password'] = 'Password must be at least 8 characters'
    elif not any(c.isupper() for c in password):
        errors['password'] = 'Password must contain at least one uppercase letter'
    elif not any(c.isdigit() for c in password):
        errors['password'] = 'Password must contain at least one digit'

    # Age validation (must be 13+)
    if birth_date:
        try:
            dob = date.fromisoformat(birth_date)
            age = (date.today() - dob).days // 365
            if age < 13:
                errors['birth_date'] = 'Must be at least 13 years old'
        except ValueError:
            errors['birth_date'] = 'Invalid date format, use YYYY-MM-DD'

    if errors:
        raise ValidationError(str(errors))

    return {"valid": True, "email": email.lower()}