Hoe test je Laravel-applicaties?

Question

Accepted Answer

Laravel biedt uitstekende ingebouwde testondersteuning (gebaseerd op PHPUnit, met de moderne Pest-optie) plus testspecifieke helpers — een testdatabase, HTTP-testing, authenticatiehelpers en fakes — waardoor applicaties zeer testbaar zijn. Tests zijn onderverdeeld in feature tests (volledige request flow) en unit tests (geïsoleerde logica).

## Feature tests — test de volledige 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** oefenen de volledige stack (routing, middleware, validatie, controller, database) door HTTP-verzoeken te doen met helpers zoals `get`/`postJson`, waarna je assertions doet op de response en databasestatus (`assertDatabaseHas`). Dit verifieert echt applicatiegedrag.

## Testing helpers maken Laravel zeer testbaar

```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()`, enz.) laten je asserteren dat e-mails zijn verzonden, jobs in de wachtrij stonden, of HTTP-oproepen zijn gedaan — *zonder* ze werkelijk uit te voeren, waardoor snelle, geïsoleerde, deterministische tests mogelijk zijn. De `actingAs` en factory helpers maken het eenvoudig om geverifieerde, data-rijke testscenario's in te stellen.

## Unit tests en 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());
```

## Waarom het belangrijk is

Testing is essentieel voor betrouwbare applicaties, en Laravel's uitstekende ingebouwde testondersteuning — met webaware helpers die applicaties opmerkelijk testbaar maken — betekent dat begrijpen hoe je test belangrijk is zowel voor codekwaliteit als als professionele verwachting. **Feature tests** zijn vooral waardevol: door echte HTTP-verzoeken aan de applicatie te doen en assertions op responses en databasestatus te doen (met het `RefreshDatabase` trait dat een geïsoleerde testdatabase biedt), verifiëren ze dat de volledige request flow (routing, middleware, validatie, controllers, persistentie) correct samenwerkt — het echte gedrag testen zoals gebruikers het ervaren.

Laravel's **testing helpers en fakes** zijn wat dit zo praktisch maakt: `actingAs` voor authenticatie, **factories** voor het genereren van testdata, en vooral de **fakes** (`Mail::fake()`, `Queue::fake()`, `Http::fake()`, `Event::fake()`) die je laten asserteren dat bijeffecten hebben plaatsgevonden (e-mails verzonden, jobs in de wachtrij, externe oproepen gedaan) *zonder* ze werkelijk uit te voeren — waardoor snelle, geïsoleerde, deterministische tests van complex gedrag mogelijk zijn.

Het begrijpen van feature versus unit tests, de testing helpers en fakes, factories voor data, en de moderne Pest-optie dekt de praktische reikwijdte van effectieve Laravel-testing.

Aangezien Laravel zo sterke, webaware testinghulpmiddelen biedt, en aangezien goed geteste applicaties regressies opvangen en zelfverzekerd refactoring mogelijk maken, is het begrijpen hoe je Laravel's testondersteuning kunt benutten — met name feature tests en de fake/factory helpers — belangrijk kennis op seniorenniveau die ontwikkelaars die robuuste, onderhoudbare applicaties bouwen onderscheidt van degenen die ongeteste, broze code uitbrengen, wat professionele engineeringpraktijk weerspiegelt.