Claude Code for QA Engineers: How to Automate Test Writing with AI (2026)

# QA Project Context

## Stack
- Python 3.11
- pytest 7.x with pytest-asyncio for async tests
- httpx for API calls (not requests)
- Bruno for API collections (not Postman)
- Faker library for test data generation
- SQLAlchemy for database fixtures

## Test patterns we use
- Arrange-Act-Assert (AAA) — always use these comment sections
- Fixtures defined in conftest.py (not inline in test files)
- Test class names: TestFeatureName (no underscores)
- Test function names: test_should_[expected_behavior]_when_[condition]
- Always parametrize when testing multiple input variants
- Use pytest.mark.integration for tests that hit external services

## Database
- Use factory_boy for model factories, not raw SQL inserts
- Always roll back transactions in teardown (use session fixture from conftest)
- Schema: PostgreSQL 15, see /schemas/ directory

## What NOT to do
- Do not use unittest.TestCase (we use pure pytest)
- Do not hardcode test data inline — use Faker or factory_boy
- Do not use time.sleep() — use pytest-asyncio with proper await
- Do not write tests that depend on execution order

## API base URL
- Local: http://localhost:8000
- The service mounts at /api/v2/ (not /api/v1/)

## Kafka schemas
See /schemas/avro/ directory. Key schemas:
- payment_initiated.avsc — emitted when payment flow starts
- payment_completed.avsc — emitted on successful capture
- kyc_status_changed.avsc — emitted by KYC service

Always import schema from file, don't hardcode field names inline.

@router.post("/payments/refund")
async def initiate_refund(
    request: RefundRequest,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user)
) -> RefundResponse:
    """Initiate a refund for a completed payment."""
    payment = await get_payment(db, request.payment_id)
    if payment is None:
        raise HTTPException(status_code=404, detail="Payment not found")
    if payment.status != PaymentStatus.COMPLETED:
        raise HTTPException(status_code=400, detail="Only completed payments can be refunded")
    if payment.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="Cannot refund another user's payment")
    
    refund = await create_refund(db, payment, request.amount)
    return RefundResponse.from_orm(refund)

Generate a pytest test file for the POST /payments/refund endpoint above.

Requirements:
- Cover: happy path, payment not found (404), wrong status (400), wrong user (403)
- Use the AAA pattern with comment sections
- Mock get_payment and create_refund at the service layer (not DB layer)
- Use httpx AsyncClient with the FastAPI app (see our TestClient setup in conftest.py)
- Use pytest.mark.asyncio for all async tests
- Follow naming convention: TestInitiateRefund class, test_should_[behavior]_when_[condition] methods
- Generate test data with Faker where needed

import pytest
from httpx import AsyncClient
from unittest.mock import AsyncMock, patch
from faker import Faker

fake = Faker()

class TestInitiateRefund:
    
    @pytest.mark.asyncio
    async def test_should_return_refund_when_payment_is_completed(
        self, async_client: AsyncClient, authenticated_user
    ):
        # Arrange
        payment_id = fake.uuid4()
        mock_payment = MockPayment(
            id=payment_id,
            status=PaymentStatus.COMPLETED,
            user_id=authenticated_user.id,
            amount=1000
        )
        mock_refund = MockRefund(payment_id=payment_id, amount=500)
        
        with patch("app.routers.payments.get_payment", return_value=mock_payment), \
             patch("app.routers.payments.create_refund", return_value=mock_refund):
            # Act
            response = await async_client.post(
                "/api/v2/payments/refund",
                json={"payment_id": payment_id, "amount": 500}
            )
        
        # Assert
        assert response.status_code == 200
        assert response.json()["payment_id"] == payment_id
    
    @pytest.mark.asyncio
    async def test_should_return_404_when_payment_not_found(
        self, async_client: AsyncClient, authenticated_user
    ):
        # Arrange
        with patch("app.routers.payments.get_payment", return_value=None):
            # Act
            response = await async_client.post(
                "/api/v2/payments/refund",
                json={"payment_id": fake.uuid4(), "amount": 500}
            )
        
        # Assert
        assert response.status_code == 404
        assert "not found" in response.json()["detail"].lower()

I have an OpenAPI 3.0 spec for our payments service (pasted below / in openapi.yaml).

Generate a Bruno collection that:
- Creates one folder per tag in the spec
- Creates one .bru file per endpoint
- Uses {{baseUrl}} variable for the host
- Includes example request bodies from the spec's examples field
- Adds a pre-request script to set Authorization: Bearer {{authToken}}
- For POST /payments/refund specifically, add a test script that asserts status 200 and response.payment_id is present

[paste spec here]

# Start Claude Code in the repo root
claude

# Then in the Claude Code session:
> Read the output of `git diff main...HEAD` and identify all changed Python functions and methods.
> For each changed function, check if a corresponding test exists in tests/.
> Generate tests for any function that has no coverage or whose tests don't cover the new code paths.
> Run pytest on the new test files only: pytest tests/test_payments.py -v
> Fix any failures and re-run until all tests pass.

claude --headless "Read git diff, generate tests for uncovered changed functions, run pytest, iterate until green. Output a summary of tests added."

Generate parametrized pytest tests for the [function/endpoint] above.
Create a parametrize decorator covering: valid input (should pass), empty string, None, too-long string, SQL injection attempt, XSS payload, Unicode edge cases (Tamil, Devanagari characters).

Generate a factory_boy factory class for the [ModelName] model above.
Include all required fields. Use Faker for string fields, realistic ranges for numeric fields. Add subfactories for related models [list them].

Given the Avro schema in /schemas/avro/payment_initiated.avsc, generate pytest tests that:
- Validate the schema parses correctly
- Test that a sample payload serializes/deserializes without data loss
- Test that required fields missing from payload raise SchemaParseException

I have two services: payment-service (producer) and notification-service (consumer). The notification-service expects the payment_completed event to have fields: payment_id (string), amount (int), currency (string, 3-char), user_email (string).
Generate a pytest contract test that verifies the payment-service schema matches these consumer expectations.

Generate a k6 load test script for the POST /payments/initiate endpoint.
Profile: ramp from 0 to 100 VUs over 30s, hold 100 VUs for 2 minutes, ramp down.
Thresholds: p95 < 500ms, error rate < 1%.
Use realistic payload from the example above.

Write Gherkin feature file scenarios for the refund flow. Cover happy path, insufficient balance, payment not eligible. Use Indian rupee amounts and realistic merchant names.

Write a pytest test for the send_refund_notification Celery task. Mock the email service. Verify the task is called with correct arguments when refund status changes to COMPLETED. Use pytest-celery fixtures.

Our payment service returns these error codes: INVALID_VPA, INSUFFICIENT_FUNDS, UPI_LIMIT_EXCEEDED, BANK_DOWN, DUPLICATE_TRANSACTION.
Generate pytest tests that verify each error code is returned under the correct conditions. Mock the UPI gateway at the httpx call level.