How To Use Claude Agents For Automated Testing

"We should add more tests someday."

"Here are 18 missing scenarios, 6 edge cases, 3 current behavior risks, and a proposed test file that passes locally."

Write tests for this service.

Analyze this service and create tests that protect the current behavior.
Do not refactor the implementation yet.
Focus on edge cases, validation rules, failed dependencies, and database state changes.
After writing tests, run the relevant test command and summarize what behavior is now covered.

final class DiscountService
{
    public function calculateDiscount(User $user, Cart $cart): int
    {
        if ($cart->total() <= 0) {
            return 0;
        }

        if ($user->isVip()) {
            return 20;
        }

        if ($cart->total() > 500) {
            return 10;
        }

        if ($user->createdAt()->diffInDays(now()) < 7) {
            return 5;
        }

        return 0;
    }
}

Analyze DiscountService and list the observable behaviors that should be protected before refactoring.
Do not suggest design changes yet.
Group the behaviors by rule priority and edge cases.

Current observable behavior:
1. Cart total <= 0 always returns 0, even for VIP users.
2. VIP users receive 20 before expensive-cart logic is checked.
3. Non-VIP users with cart total > 500 receive 10.
4. New non-VIP users with cart total <= 500 receive 5.
5. Existing non-VIP users with cart total <= 500 receive 0.

Create PHPUnit tests for the observable behaviors listed above.
Use clear test method names.
Avoid mocks unless needed.
Do not change production code.

final class DiscountServiceTest extends TestCase
{
    public function test_zero_total_cart_gets_no_discount_even_for_vip_user(): void
    {
        $user = UserFactory::vip()->make();
        $cart = CartFactory::withTotal(0)->make();

        $discount = (new DiscountService())->calculateDiscount($user, $cart);

        $this->assertSame(0, $discount);
    }

    public function test_vip_user_gets_twenty_percent_before_expensive_cart_rule(): void
    {
        $user = UserFactory::vip()->make();
        $cart = CartFactory::withTotal(1000)->make();

        $discount = (new DiscountService())->calculateDiscount($user, $cart);

        $this->assertSame(20, $discount);
    }

    public function test_non_vip_user_with_expensive_cart_gets_ten_percent(): void
    {
        $user = UserFactory::regular()->make();
        $cart = CartFactory::withTotal(700)->make();

        $discount = (new DiscountService())->calculateDiscount($user, $cart);

        $this->assertSame(10, $discount);
    }
}

Testing Strategist Agent
- Reads the service.
- Finds behavior and risk.
- Creates a test plan.
- Does not write test files.

Test Writer Agent
- Uses the approved test plan.
- Creates test code.
- Follows project conventions.
- Does not refactor production code.

Test Runner Agent
- Runs the relevant test command.
- Reports failures.
- Does not rewrite code unless asked.

Coverage Reviewer Agent
- Compares changed code with tests.
- Finds missing edge cases.
- Suggests next tests.

You are a Testing Strategist Agent.

Goal:
Analyze the current service and produce a test plan.

Rules:
- Do not modify files.
- Do not propose refactoring yet.
- Focus on observable behavior.
- Identify edge cases and failure modes.
- Mark each test as unit, integration, regression, or characterization.

Output:
1. Behavior summary
2. Risky branches
3. Proposed test cases
4. Required fixtures or factories
5. Commands to run after tests are created

You are a Test Writer Agent.

Use the approved test plan below.
Create tests only.
Follow existing test style in this repository.
Do not change production code.
After writing tests, explain which files changed and why.

final class PasswordPolicy
{
    public function validate(string $password): array
    {
        $errors = [];

        if (strlen($password) < 12) {
            $errors[] = 'Password must be at least 12 characters.';
        }

        if (! preg_match('/[A-Z]/', $password)) {
            $errors[] = 'Password must contain an uppercase letter.';
        }

        if (! preg_match('/[0-9]/', $password)) {
            $errors[] = 'Password must contain a number.';
        }

        if (str_contains(strtolower($password), 'password')) {
            $errors[] = 'Password must not contain the word password.';
        }

        return $errors;
    }
}

Create a compact PHPUnit test matrix for PasswordPolicy.
Cover minimum length, uppercase, number, forbidden word, valid password, and multiple errors in one password.
Use a data provider where it improves readability.

final class PasswordPolicyTest extends TestCase
{
    /**
     * @dataProvider passwordProvider
     */
    public function test_it_validates_password_rules(string $password, array $expectedErrors): void
    {
        $errors = (new PasswordPolicy())->validate($password);

        $this->assertSame($expectedErrors, $errors);
    }

    public static function passwordProvider(): array
    {
        return [
            'valid password' => [
                'SafePassword123',
                [],
            ],
            'too short' => [
                'Short1',
                ['Password must be at least 12 characters.'],
            ],
            'missing uppercase' => [
                'safe-password-123',
                ['Password must contain an uppercase letter.'],
            ],
            'missing number' => [
                'SafePasswordText',
                [
                    'Password must contain a number.',
                    'Password must not contain the word password.',
                ],
            ],
        ];
    }
}

'valid password' => [
    'SecureToken123',
    [],
],

final class CreateOrderAction
{
    public function __construct(
        private PaymentGateway $payments,
        private Dispatcher $events,
    ) {}

    public function execute(User $user, Cart $cart): Order
    {
        return DB::transaction(function () use ($user, $cart) {
            $order = Order::create([
                'user_id' => $user->id,
                'total' => $cart->total(),
                'status' => 'pending',
            ]);

            $charge = $this->payments->charge($user, $cart->total());

            $order->update([
                'status' => 'paid',
                'payment_id' => $charge->id,
            ]);

            SendReceiptJob::dispatch($order->id);

            return $order;
        });
    }
}

Write tests for CreateOrderAction.

Analyze CreateOrderAction and create integration tests for database state, payment gateway success, payment gateway failure, transaction rollback, and receipt job dispatching.
Use Laravel testing helpers where appropriate.
Do not hit real external services.
Use fakes or mocks for payment and queues.

public function test_it_creates_paid_order_and_dispatches_receipt(): void
{
    Queue::fake();

    $user = User::factory()->create();
    $cart = CartFactory::withTotal(15000)->createForUser($user);

    $paymentGateway = Mockery::mock(PaymentGateway::class);
    $paymentGateway
        ->shouldReceive('charge')
        ->once()
        ->andReturn(new ChargeResult(id: 'ch_123'));

    $order = (new CreateOrderAction($paymentGateway, app(Dispatcher::class)))
        ->execute($user, $cart);

    $this->assertDatabaseHas('orders', [
        'id' => $order->id,
        'status' => 'paid',
        'payment_id' => 'ch_123',
    ]);

    Queue::assertPushed(SendReceiptJob::class, function (SendReceiptJob $job) use ($order) {
        return $job->orderId === $order->id;
    });
}

public function test_it_rolls_back_order_when_payment_fails(): void
{
    Queue::fake();

    $user = User::factory()->create();
    $cart = CartFactory::withTotal(15000)->createForUser($user);

    $paymentGateway = Mockery::mock(PaymentGateway::class);
    $paymentGateway
        ->shouldReceive('charge')
        ->once()
        ->andThrow(new PaymentFailedException('Card declined'));

    $this->expectException(PaymentFailedException::class);

    try {
        (new CreateOrderAction($paymentGateway, app(Dispatcher::class)))
            ->execute($user, $cart);
    } finally {
        $this->assertDatabaseMissing('orders', [
            'user_id' => $user->id,
            'status' => 'pending',
        ]);

        Queue::assertNothingPushed();
    }
}

Users with expired subscriptions can still access premium videos if they refresh the page after midnight UTC.

Create a regression test for this bug:
"Users with expired subscriptions can still access premium videos if they refresh the page after midnight UTC."

Steps:
1. Find the authorization logic for premium video access.
2. Identify how subscription expiration is checked.
3. Create a failing test that reproduces the bug.
4. Do not fix production code yet.
5. Explain why the test fails.

Bug report
   ↓
Failing regression test
   ↓
Production fix
   ↓
Passing test
   ↓
Protected behavior

Create test data categories for an address validation service.
Include valid addresses, missing required fields, invalid postal codes, apartment numbers, international addresses, PO boxes, and provider timeout cases.
Do not invent provider-specific behavior unless it exists in the code or docs.

return [
    'valid US address with apartment' => [
        [
            'line1' => '123 Main St',
            'line2' => 'Apt 4B',
            'city' => 'Minneapolis',
            'state' => 'MN',
            'postal_code' => '55401',
            'country' => 'US',
        ],
        true,
    ],
    'missing postal code' => [
        [
            'line1' => '123 Main St',
            'city' => 'Minneapolis',
            'state' => 'MN',
            'country' => 'US',
        ],
        false,
    ],
];

Find edge cases for this price calculation service.
Focus on rounding, zero values, negative values, currency mismatch, discounts larger than subtotal, tax order, duplicate coupons, and integer overflow.
Return a prioritized list of test cases.

Find edge cases for this endpoint.
Focus on authentication, authorization, missing fields, malformed JSON, idempotency, duplicate requests, race conditions, pagination limits, and unexpected enum values.

Find edge cases for this queue job.
Focus on retries, duplicate execution, failed dependencies, partial database updates, idempotency, and poison messages.

Analyze these CI failures and identify possible flaky test causes.
Group by category: time dependency, shared database state, ordering dependency, external service dependency, random data, async race, or resource limits.
For each category, suggest a deterministic fix.

Uses now() without freezing time.
Depends on test execution order.
Uses real network calls.
Waits with sleep(1) instead of polling with timeout.
Shares mutable global state.
Uses random data without fixed seed.
Assumes queue jobs finish immediately.

public function test_trial_expires_after_seven_days(): void
{
    Carbon::setTestNow('2026-05-03 10:00:00');

    $user = User::factory()->create([
        'trial_started_at' => now()->subDays(8),
    ]);

    $this->assertTrue($user->trialExpired());
}

Compare the changed production files with existing tests.
Find behavior that changed but is not directly covered by tests.
Ignore simple getters and framework boilerplate.
Prioritize payment, authorization, data deletion, queue dispatching, external API calls, and database writes.

Increase coverage to 90%.

Coverage gaps found:

High risk:
- Subscription cancellation now deletes scheduled renewal jobs, but no test asserts jobs are removed.
- Payment retry logic catches GatewayTimeoutException, but no test covers retry behavior.

Medium risk:
- User export now includes phone number, but API response test was not updated.

Low risk:
- New helper formats display name, simple branch not covered.

Developer opens PR
   ↓
Testing Agent reads diff
   ↓
Agent identifies changed behavior
   ↓
Agent checks existing tests
   ↓
Agent suggests missing test cases
   ↓
Developer approves useful cases
   ↓
Agent writes tests
   ↓
CI runs
   ↓
Agent summarizes test protection in PR comment

Testing summary:

Added:
- Regression test for failed payment retry after timeout.
- Integration test for order rollback when gateway throws exception.
- Unit test for discount priority between VIP and cart total rules.

Not covered:
- Concurrent duplicate checkout requests. This likely needs an idempotency test.

Commands run:
- php artisan test --filter=CreateOrderActionTest
- vendor/bin/phpunit tests/Unit/DiscountServiceTest.php

Do not change production code unless explicitly asked.
Do not delete existing tests.
Do not weaken assertions to make tests pass.
Do not replace specific assertions with assertTrue(true)-style checks.
Do not mock the class under test.
Do not hide failures.
Do not update snapshots without explaining behavior changes.
Do not invent business requirements.

Assumption: expired subscriptions should not access premium videos.
Evidence: SubscriptionPolicy::canAccessPremium() checks expires_at.
Need confirmation: grace period behavior is not documented.

You are a senior testing agent working inside this repository.

Goal:
Create tests that protect current behavior and reduce regression risk.

Process:
1. Inspect the target code and nearby tests.
2. Summarize current observable behavior.
3. Identify risky branches, edge cases, and failure paths.
4. Propose a test plan before writing tests.
5. After approval, write tests only.
6. Run the smallest relevant test command.
7. Report what passed, what failed, and what behavior is protected.

Rules:
- Do not refactor production code.
- Do not change behavior to satisfy tests.
- Do not remove existing tests.
- Prefer clear assertions over broad snapshots.
- Use factories and fakes already used in this project.
- Label assumptions clearly.

Focus areas:
- Unit tests
- Integration tests
- Regression tests
- Characterization tests
- Test data generation
- Edge cases
- Flaky test risks
- Coverage gaps