How do you test Laravel applications?

Question

Accepted Answer

Laravel provides excellent built-in testing support (on PHPUnit, with the modern Pest option) plus testing-specific helpers — a test database, HTTP testing, authentication helpers, and fakes — making applications highly testable. Tests are split into feature tests (full request flow) and unit tests (isolated logic).

## Feature tests — test the full request flow

```php
class UserTest extends TestCase {
    use RefreshDatabase;            // fresh, migrated test database per test (isolated)

public function test_can_create_user(): void {
        $response = $this->postJson('/api/users', [    // make a real request to the app
            'name' => 'Ann', 'email' => 'ann@x.com',
        ]);
        $response->assertStatus(201)
                 ->assertJson(['name' => 'Ann']);       // assert the response
        $this->assertDatabaseHas('users', ['email' => 'ann@x.com']);   // assert the DB
    }
}
```

**Feature tests** exercise the full stack (routing, middleware, validation, controller, database) by making HTTP requests with helpers like `get`/`postJson`, then asserting on the response and database state (`assertDatabaseHas`). This verifies real application behavior.

## Testing helpers make Laravel highly testable

```php
$this->actingAs($user)->get('/dashboard');         // authenticate as a user
User::factory()->count(10)->create();               // generate test data via factories

Mail::fake(); Mail::assertSent(WelcomeEmail::class);   // assert mail without sending
Queue::fake(); Queue::assertPushed(ProcessJob::class); // assert jobs queued, don't run them
Event::fake(); Storage::fake('s3');                    // fake events, storage, etc.
Http::fake();                                           // fake external HTTP calls
```

Laravel's **fakes** (`Mail::fake()`, `Queue::fake()`, `Http::fake()`, etc.) let you assert that emails were sent, jobs were queued, or HTTP calls were made — *without* actually performing them, enabling fast, isolated, deterministic tests. The `actingAs` and factory helpers make setting up authenticated, data-rich test scenarios easy.

## Unit tests and Pest

```php
// unit test — isolated logic, no framework/DB
public function test_discount_calculation(): void {
    $this->assertEquals(90, (new Cart)->applyDiscount(100, 10));
}

// Pest — a modern, expressive testing syntax on top of PHPUnit (popular in Laravel)
it('creates a user', fn() => post('/users', [...])->assertCreated());
```

## Why it matters

Testing is essential for reliable applications, and Laravel's excellent built-in testing support — with web-aware helpers that make applications notably testable — means understanding how to test is important both for code quality and as a professional expectation. **Feature tests** are especially valuable: by making real HTTP requests to the application and asserting on responses and database state (with the `RefreshDatabase` trait providing an isolated test database), they verify the entire request flow (routing, middleware, validation, controllers, persistence) works correctly together — testing real behavior as users experience it.

Laravel's **testing helpers and fakes** are what make this so practical: `actingAs` for authentication, **factories** for generating test data, and especially the **fakes** (`Mail::fake()`, `Queue::fake()`, `Http::fake()`, `Event::fake()`) that let you assert side effects happened (emails sent, jobs queued, external calls made) *without* actually performing them — enabling fast, isolated, deterministic tests of complex behavior.

Understanding feature vs unit tests, the testing helpers and fakes, factories for data, and the modern Pest option covers the practical scope of testing Laravel effectively.

Since Laravel provides such strong, web-aware testing tools, and since well-tested applications catch regressions and enable confident refactoring, knowing how to leverage Laravel's testing support — particularly feature tests and the fake/factory helpers — is important senior-level knowledge that distinguishes developers who build robust, maintainable applications from those who ship untested, fragile code, reflecting professional engineering practice.