HTTP-tests - Knowledge of Laravel

Introductie

Laravel biedt een rijke API om HTTP-requests te simuleren en responses te verifiëren. Je kunt requests aan je applicatie binnen tests nabootsen zonder een echte HTTP-server op te zetten.

<?php

test('de applicatie geeft een succesvolle response terug', function () {
    $response = $this->get('/');

    $response->assertStatus(200);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_the_application_returns_a_successful_response(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

De methode get() stuurt een GET-request naar de applicatie en assertStatus() verifieert de HTTP-statuscode van de teruggekregen response.

Tijdens het uitvoeren van tests wordt de CSRF-middleware automatisch uitgeschakeld. Je hoeft die in tests niet expliciet uit te schakelen.

Requests maken

Binnen tests kun je requests versturen met de methoden get, post, put, patch en delete. Deze methoden versturen geen echt netwerkrequest, maar simuleren het binnen de applicatie. De retourwaarde is een instantie van Illuminate\Testing\TestResponse, die diverse assertion-methoden biedt.

<?php

test('een basisrequest', function () {
    $response = $this->get('/');

    $response->assertStatus(200);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_a_basic_request(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

Het is aan te raden om binnen één testmethode in principe maar één request te versturen. Meerdere requests binnen dezelfde test uitvoeren kan onverwacht gedrag veroorzaken.

Requestheaders aanpassen

Met de methode withHeaders() pas je de headers van het request aan.

<?php

test('request met headers', function () {
    $response = $this->withHeaders([
        'X-Header' => 'Value',
    ])->post('/user', ['name' => 'Sally']);

    $response->assertStatus(201);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

Cookies

Met de methoden withCookie() of withCookies() stel je cookiewaarden in vóór het request.

<?php

test('request met cookies', function () {
    $response = $this->withCookie('color', 'blue')->get('/');

    $response = $this->withCookies([
        'color' => 'blue',
        'name'  => 'Taylor',
    ])->get('/');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_interacting_with_cookies(): void
    {
        $response = $this->withCookie('color', 'blue')->get('/');

        $response = $this->withCookies([
            'color' => 'blue',
            'name'  => 'Taylor',
        ])->get('/');
    }
}

Sessie en authenticatie

Met de methode withSession() stel je sessiedata in vóór het request.

<?php

test('request met sessie', function () {
    $response = $this->withSession(['banned' => false])->get('/');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_interacting_with_the_session(): void
    {
        $response = $this->withSession(['banned' => false])->get('/');
    }
}

Met de methode actingAs() verstuur je requests als geauthenticeerde gebruiker. Je gebruikt dit in combinatie met modelfactory’s.

<?php

use App\Models\User;

test('een actie die authenticatie vereist', function () {
    $user = User::factory()->create();

    $response = $this->actingAs($user)
        ->withSession(['banned' => false])
        ->get('/');
});

<?php

namespace Tests\Feature;

use App\Models\User;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_an_action_that_requires_authentication(): void
    {
        $user = User::factory()->create();

        $response = $this->actingAs($user)
            ->withSession(['banned' => false])
            ->get('/');
    }
}

Geef je de guardnaam door als tweede argument van actingAs(), dan wordt met die guard geauthenticeerd. Voor de duur van de test wordt die guard de standaard.

$this->actingAs($user, 'web');

Wil je een request versturen zonder authenticatie, gebruik dan actingAsGuest().

$this->actingAsGuest();

Responses debuggen

Wil je tijdens een test de inhoud van de response bekijken, gebruik dan de methoden dump, dumpHeaders en dumpSession.

<?php

test('response debuggen', function () {
    $response = $this->get('/');

    $response->dump();
    $response->dumpHeaders();
    $response->dumpSession();
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_debug_response(): void
    {
        $response = $this->get('/');

        $response->dump();
        $response->dumpHeaders();
        $response->dumpSession();
    }
}

Wil je de uitvoering stoppen, gebruik dan de methoden dd, ddHeaders, ddBody, ddJson en ddSession.

$response->dd();
$response->ddHeaders();
$response->ddBody();
$response->ddJson();
$response->ddSession();

Excepties testen

Om te testen dat een specifieke exceptie wordt gegooid, gebruik je de Exceptions-facade.

<?php

use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;

test('exceptie wordt gegooid', function () {
    Exceptions::fake();

    $response = $this->get('/order/1');

    // Controleren dat de exceptie is gegooid
    Exceptions::assertReported(InvalidOrderException::class);

    // De inhoud van de exceptie controleren
    Exceptions::assertReported(function (InvalidOrderException $e) {
        return $e->getMessage() === 'The order was invalid.';
    });
});

<?php

namespace Tests\Feature;

use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_exception_is_thrown(): void
    {
        Exceptions::fake();

        $response = $this->get('/');

        Exceptions::assertReported(InvalidOrderException::class);

        Exceptions::assertReported(function (InvalidOrderException $e) {
            return $e->getMessage() === 'The order was invalid.';
        });
    }
}

Om te controleren dat een exceptie niet is gegooid, gebruik je assertNotReported of assertNothingReported.

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

Wil je een request versturen met uitgeschakelde exceptieafhandeling, gebruik dan withoutExceptionHandling().

$response = $this->withoutExceptionHandling()->get('/');

Om te testen of code in een closure een exceptie gooit, gebruik je assertThrows().

$this->assertThrows(
    fn () => (new ProcessOrder)->execute(),
    OrderInvalid::class
);

// De inhoud van de exceptie controleren
$this->assertThrows(
    fn () => (new ProcessOrder)->execute(),
    fn (OrderInvalid $e) => $e->orderId() === 123
);

Om te controleren dat er geen exceptie wordt gegooid, gebruik je assertDoesntThrow().

$this->assertDoesntThrow(fn () => (new ProcessOrder)->execute());

JSON-API’s testen

Laravel biedt veel helpers voor het testen van JSON-API’s. Met de methoden json, getJson, postJson, putJson, patchJson, deleteJson en optionsJson verstuur je JSON-requests.

<?php

test('een API-request versturen', function () {
    $response = $this->postJson('/api/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertJson([
            'created' => true,
        ]);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_making_an_api_request(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertJson([
                'created' => true,
            ]);
    }
}

Op de data van een JSON-response heb je toegang als arrayvariabele.

expect($response['created'])->toBeTrue();

$this->assertTrue($response['created']);

assertJson() zet de response om naar een array en verifieert of de opgegeven array in de JSON-response voorkomt. Ook als de JSON andere properties bevat, slaagt de test zolang het opgegeven fragment aanwezig is.

Assertions op exacte overeenkomst

Met assertExactJson() verifieer je dat de teruggegeven JSON exact overeenkomt met de opgegeven array.

<?php

test('JSON-assertion op exacte overeenkomst', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertExactJson([
            'created' => true,
        ]);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_asserting_an_exact_json_match(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertExactJson([
                'created' => true,
            ]);
    }
}

Assertions op JSON-paden

Met assertJsonPath() verifieer je de data op een opgegeven pad.

<?php

test('assertion op een JSON-pad', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertJsonPath('team.owner.name', 'Darian');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertJsonPath('team.owner.name', 'Darian');
    }
}

Je kunt ook een closure doorgeven voor flexibelere verificatie.

$response->assertJsonPath('team.owner.name', fn (string $name) => strlen($name) >= 3);

Fluente JSON-tests

Geef je een closure door aan assertJson(), dan kun je met een AssertableJson-instantie fluent assertions schrijven.

use Illuminate\Testing\Fluent\AssertableJson;

test('fluente JSON-test', function () {
    $response = $this->getJson('/users/1');

    $response
        ->assertJson(fn (AssertableJson $json) =>
            $json->where('id', 1)
                ->where('name', 'Victoria Faith')
                ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                ->whereNot('status', 'pending')
                ->missing('password')
                ->etc()
        );
});

use Illuminate\Testing\Fluent\AssertableJson;

public function test_fluent_json(): void
{
    $response = $this->getJson('/users/1');

    $response
        ->assertJson(fn (AssertableJson $json) =>
            $json->where('id', 1)
                ->where('name', 'Victoria Faith')
                ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                ->whereNot('status', 'pending')
                ->missing('password')
                ->etc()
        );
}

De methode etc() staat toe dat er properties bestaan waarop geen assertion is gedaan. Gebruik je etc() niet, dan faalt de test wanneer er properties bestaan waar je geen assertion op doet. Zo voorkom je dat je onbedoeld gevoelige informatie in de response opneemt.

Om de aan- of afwezigheid van attributen te controleren gebruik je has() en missing().

$response->assertJson(fn (AssertableJson $json) =>
    $json->has('data')
        ->missing('message')
);

Om meerdere attributen tegelijk te controleren gebruik je hasAll() en missingAll().

$response->assertJson(fn (AssertableJson $json) =>
    $json->hasAll(['status', 'data'])
        ->missingAll(['message', 'code'])
);

Assertions op JSON-collecties

Geeft een route een JSON-response met meerdere items terug, dan kun je met de methode has() het aantal items en de inhoud van de collectie verifiëren.

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has(3)
            ->first(fn (AssertableJson $json) =>
                $json->where('id', 1)
                    ->where('name', 'Victoria Faith')
                    ->missing('password')
                    ->etc()
            )
    );

Om dezelfde assertions op alle items toe te passen gebruik je each().

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has(3)
            ->each(fn (AssertableJson $json) =>
                $json->whereType('id', 'integer')
                    ->whereType('name', 'string')
                    ->whereType('email', 'string')
                    ->missing('password')
                    ->etc()
            )
    );

Assertions op JSON-types

Met whereType() en whereAllType() verifieer je het type van properties.

$response->assertJson(fn (AssertableJson $json) =>
    $json->whereType('id', 'integer')
        ->whereAllType([
            'users.0.name' => 'string',
            'meta' => 'array'
        ])
);

Met het |-teken kun je ook meerdere types opgeven. De assertion slaagt zodra één van de types overeenkomt.

$response->assertJson(fn (AssertableJson $json) =>
    $json->whereType('name', 'string|null')
        ->whereType('id', ['string', 'integer'])
);

De beschikbare types zijn string, integer, double, boolean, array en null.

Authenticatietests

Met actingAs() verstuur je requests als geauthenticeerde gebruiker.

<?php

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(RefreshDatabase::class);

test('geauthenticeerde gebruiker kan het dashboard bekijken', function () {
    $user = User::factory()->create();

    $response = $this->actingAs($user)->get('/dashboard');

    $response->assertStatus(200);
});

test('niet-geauthenticeerde gebruiker wordt geredirect', function () {
    $response = $this->get('/dashboard');

    $response->assertRedirect('/login');
});

<?php

namespace Tests\Feature;

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class DashboardTest extends TestCase
{
    use RefreshDatabase;

    public function test_authenticated_users_can_view_the_dashboard(): void
    {
        $user = User::factory()->create();

        $response = $this->actingAs($user)->get('/dashboard');

        $response->assertStatus(200);
    }

    public function test_unauthenticated_users_are_redirected(): void
    {
        $response = $this->get('/dashboard');

        $response->assertRedirect('/login');
    }
}

Om met een specifieke guard te authenticeren geef je de guardnaam op als tweede argument.

$this->actingAs($user, 'api');

Voorbeeld: de registratieflow testen

Een voorbeeld waarin het echte registratie-endpoint wordt getest.

<?php

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(RefreshDatabase::class);

test('gebruiker kan zich registreren', function () {
    $response = $this->post('/register', [
        'name'                  => 'Test User',
        'email'                 => '[email protected]',
        'password'              => 'password',
        'password_confirmation' => 'password',
    ]);

    $response->assertRedirect('/dashboard');
    $this->assertDatabaseHas('users', ['email' => '[email protected]']);
});

test('registreren met een dubbel e-mailadres is niet mogelijk', function () {
    User::factory()->create(['email' => '[email protected]']);

    $response = $this->post('/register', [
        'name'                  => 'Test User',
        'email'                 => '[email protected]',
        'password'              => 'password',
        'password_confirmation' => 'password',
    ]);

    $response->assertSessionHasErrors('email');
});

<?php

namespace Tests\Feature;

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class RegistrationTest extends TestCase
{
    use RefreshDatabase;

    public function test_user_can_register(): void
    {
        $response = $this->post('/register', [
            'name'                  => 'Test User',
            'email'                 => '[email protected]',
            'password'              => 'password',
            'password_confirmation' => 'password',
        ]);

        $response->assertRedirect('/dashboard');
        $this->assertDatabaseHas('users', ['email' => '[email protected]']);
    }

    public function test_duplicate_email_cannot_register(): void
    {
        User::factory()->create(['email' => '[email protected]']);

        $response = $this->post('/register', [
            'name'                  => 'Test User',
            'email'                 => '[email protected]',
            'password'              => 'password',
            'password_confirmation' => 'password',
        ]);

        $response->assertSessionHasErrors('email');
    }
}

Sessies testen

Met withSession() stel je vooraf sessiedata in en verstuur je vervolgens het request. Met assertSessionHas() verifieer je of een waarde in de sessie bestaat.

<?php

test('sessiewaarde verifiëren', function () {
    $response = $this->withSession(['locale' => 'ja'])->get('/');

    $response->assertSessionHas('locale', 'ja');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class SessionTest extends TestCase
{
    public function test_session_value(): void
    {
        $response = $this->withSession(['locale' => 'ja'])->get('/');

        $response->assertSessionHas('locale', 'ja');
    }
}

Overzicht van sessie-assertions

Methode	Beschrijving
`assertSessionHas($key, $value)`	De opgegeven sleutel en waarde bestaan in de sessie
`assertSessionHasAll([...])`	Meerdere sleutels en waarden bestaan in de sessie
`assertSessionHasErrors($keys)`	Er bestaan validatiefouten in de sessie
`assertSessionHasErrorsIn($bag, $keys)`	Er bestaan fouten in de opgegeven error bag
`assertSessionHasNoErrors()`	Er bestaan geen validatiefouten in de sessie
`assertSessionDoesntHaveErrors()`	Er bestaan geen validatiefouten in de sessie
`assertSessionMissing($key)`	De opgegeven sleutel bestaat niet in de sessie

Bestandsuploads testen

Met de methode fake() van de klasse Illuminate\Http\UploadedFile genereer je dummybestanden of -afbeeldingen. In combinatie met de methode fake() van de Storage-facade test je bestandsuploads eenvoudig.

<?php

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

test('avatarafbeelding kan worden geüpload', function () {
    Storage::fake('avatars');

    $file = UploadedFile::fake()->image('avatar.jpg');

    $response = $this->post('/avatar', [
        'avatar' => $file,
    ]);

    Storage::disk('avatars')->assertExists($file->hashName());
});

<?php

namespace Tests\Feature;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;

class AvatarTest extends TestCase
{
    public function test_avatars_can_be_uploaded(): void
    {
        Storage::fake('avatars');

        $file = UploadedFile::fake()->image('avatar.jpg');

        $response = $this->post('/avatar', [
            'avatar' => $file,
        ]);

        Storage::disk('avatars')->assertExists($file->hashName());
    }
}

Om te controleren dat een bestand niet bestaat, gebruik je assertMissing().

Storage::disk('avatars')->assertMissing('missing.jpg');

Dummybestanden aanpassen

Je kunt de afmetingen en bestandsgrootte van afbeeldingen opgeven. Handig voor het testen van validatieregels.

// Breedte, hoogte en bestandsgrootte opgeven (grootte in KB)
UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);

// Een willekeurig bestandstype aanmaken
UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);

// Het MIME-type expliciet opgeven
UploadedFile::fake()->create(
    'document.pdf', $sizeInKilobytes, 'application/pdf'
);

Views testen

Je kunt views direct renderen en testen zonder een HTTP-request te simuleren. De methode view() accepteert een viewnaam en optioneel een array met data, en geeft een instantie van Illuminate\Testing\TestView terug.

<?php

test('de welkomstview wordt gerenderd', function () {
    $view = $this->view('welcome', ['name' => 'Taylor']);

    $view->assertSee('Taylor');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ViewTest extends TestCase
{
    public function test_a_welcome_view_can_be_rendered(): void
    {
        $view = $this->view('welcome', ['name' => 'Taylor']);

        $view->assertSee('Taylor');
    }
}

Op de TestView-klasse zijn de volgende assertion-methoden beschikbaar.

Methode	Beschrijving
`assertSee($value)`	De view bevat de opgegeven string
`assertSeeInOrder([...])`	De view bevat de opgegeven strings in volgorde
`assertSeeText($value)`	De tekst van de view bevat de opgegeven string
`assertSeeTextInOrder([...])`	De tekst van de view bevat de opgegeven strings in volgorde
`assertDontSee($value)`	De view bevat de opgegeven string niet
`assertDontSeeText($value)`	De tekst van de view bevat de opgegeven string niet

Om de inhoud van de gerenderde view als string op te halen, cast je de TestView-instantie naar een string.

$contents = (string) $this->view('welcome');

Om validatiefouten door te geven aan een view gebruik je withViewErrors().

$view = $this->withViewErrors([
    'name' => ['Voer een geldige naam in.']
])->view('form');

$view->assertSee('Voer een geldige naam in.');

Componenten testen

Met de methode blade() render je een ruwe Blade-templatestring.

$view = $this->blade(
    '<x-component :name="$name" />',
    ['name' => 'Taylor']
);

$view->assertSee('Taylor');

Met de methode component() render je een Blade-component. Deze geeft een instantie van Illuminate\Testing\TestComponent terug.

$view = $this->component(Profile::class, ['name' => 'Taylor']);

$view->assertSee('Taylor');

Overzicht van response-assertions

De belangrijkste assertion-methoden van de klasse Illuminate\Testing\TestResponse.

HTTP-status

Methode	Beschrijving
`assertOk()`	200 OK
`assertCreated()`	201 Created
`assertAccepted()`	202 Accepted
`assertNoContent($status = 204)`	204 No Content
`assertBadRequest()`	400 Bad Request
`assertUnauthorized()`	401 Unauthorized
`assertForbidden()`	403 Forbidden
`assertNotFound()`	404 Not Found
`assertUnprocessable()`	422 Unprocessable Entity
`assertTooManyRequests()`	429 Too Many Requests
`assertInternalServerError()`	500 Internal Server Error
`assertStatus($code)`	De opgegeven statuscode
`assertSuccessful()`	Een 2xx-statuscode
`assertClientError()`	Een 4xx-statuscode
`assertServerError()`	Een 5xx-statuscode

Redirects

Methode	Beschrijving
`assertRedirect($uri)`	Redirect naar de opgegeven URI
`assertRedirectContains($string)`	De redirect-URI bevat de opgegeven string
`assertRedirectToRoute($name, $params)`	Redirect naar de opgegeven route
`assertRedirectToSignedRoute($name, $params)`	Redirect naar de opgegeven signed route
`assertRedirectBack()`	Redirect naar de vorige URL

Content

Methode	Beschrijving
`assertSee($value, $escaped = true)`	De opgegeven waarde komt voor in de response
`assertSeeInOrder(array $values)`	De opgegeven waarden komen in volgorde voor
`assertSeeText($value)`	De opgegeven tekst komt voor
`assertDontSee($value)`	De opgegeven waarde komt niet voor
`assertDontSeeText($value)`	De opgegeven tekst komt niet voor
`assertContent($value)`	De responsebody komt overeen met de opgegeven waarde
`assertDownload($filename)`	Het is een downloadresponse

JSON

Methode	Beschrijving
`assertJson(array $data)`	De JSON-response bevat de opgegeven data
`assertExactJson(array $data)`	De JSON-response komt exact overeen met de opgegeven data
`assertJsonPath($path, $value)`	De waarde op het opgegeven pad komt overeen
`assertJsonMissingPath($path)`	Het opgegeven pad bestaat niet
`assertJsonStructure(array $structure)`	De JSON heeft de opgegeven structuur
`assertJsonCount($count, $key)`	De JSON van de opgegeven sleutel heeft het opgegeven aantal elementen
`assertJsonFragment(array $data)`	De JSON bevat het opgegeven fragment
`assertJsonMissing(array $data)`	De JSON bevat de opgegeven data niet
`assertJsonIsArray()`	De JSON is een array
`assertJsonIsObject()`	De JSON is een object
`assertJsonValidationErrors($keys)`	Er zijn validatiefouten voor de opgegeven sleutels
`assertJsonMissingValidationErrors($keys)`	Er zijn geen validatiefouten voor de opgegeven sleutels

Headers en cookies

Methode	Beschrijving
`assertHeader($headerName, $value)`	De opgegeven header bestaat
`assertHeaderMissing($headerName)`	De opgegeven header bestaat niet
`assertCookie($name, $value)`	De opgegeven cookie bestaat
`assertCookieExpired($name)`	De opgegeven cookie is verlopen
`assertCookieMissing($name)`	De opgegeven cookie bestaat niet
`assertPlainCookie($name, $value)`	De opgegeven niet-versleutelde cookie bestaat

Views

Methode	Beschrijving
`assertViewIs($value)`	De opgegeven view is teruggegeven
`assertViewHas($key, $value)`	De opgegeven data bestaat in de view
`assertViewHasAll(array $data)`	Meerdere datawaarden bestaan in de view
`assertViewMissing($key)`	De opgegeven data bestaat niet in de view

Validatie

Methode	Beschrijving
`assertValid($keys)`	Geen validatiefouten voor de opgegeven sleutels
`assertInvalid($keys)`	Validatiefouten voor de opgegeven sleutels

Tips om TDD in de praktijk te brengen

HTTP-tests passen uitstekend bij TDD (testgedreven ontwikkeling). Houd de volgende punten in gedachten voor het beste resultaat.

Begin met feature-tests

HTTP-tests maak je aan in de directory tests/Feature/. Door eerst het gedrag van buitenaf te definiëren (request → response) wordt duidelijk welke functionaliteit je moet implementeren.

Gebruik RefreshDatabase

Gebruik in tests die de database gebruiken de trait RefreshDatabase. Na elke test wordt de database gereset, waardoor data-interferentie tussen tests wordt voorkomen. Door tests onafhankelijk te houden bouw je een stabiele testsuite die niet afhangt van de uitvoeringsvolgorde.

Gebruik factory's actief

Met modelfactory’s zoals User::factory()->create() maak je testdata eenvoudig aan. Door factory-states te definiëren voor modellen met een specifieke toestand verbeter je de leesbaarheid van je tests.

Eén test, één assertion

Verifieer in één testmethode zo veel mogelijk maar één ding. Zo is de oorzaak makkelijker te achterhalen wanneer een test faalt. Met het AAA-patroon “Arrange (voorbereiden) → Act (uitvoeren) → Assert (verifiëren)” in gedachten worden je tests leesbaarder.

Vergeet authenticatietests niet

Schrijf voor routes die authenticatie vereisen altijd tests voor zowel het “geauthenticeerde” als het “niet-geauthenticeerde” geval. Zo ontdek je beveiligingsproblemen vroegtijdig.

Gerelateerde pagina’s

Introductie tot testen

Bekijk de basis van het schrijven van tests in Laravel en het gebruik van php artisan test.

​Introductie

​Requests maken

​Requestheaders aanpassen

​Cookies

​Sessie en authenticatie

​Responses debuggen

​Excepties testen

​JSON-API’s testen

​Assertions op exacte overeenkomst

​Assertions op JSON-paden

​Fluente JSON-tests

​Assertions op JSON-collecties

​Assertions op JSON-types

​Authenticatietests

​Voorbeeld: de registratieflow testen

​Sessies testen

​Overzicht van sessie-assertions

​Bestandsuploads testen

​Dummybestanden aanpassen

​Views testen

​Componenten testen

​Overzicht van response-assertions

​HTTP-status

​Redirects

​Content

​JSON

​Headers en cookies

​Views

​Validatie

​Tips om TDD in de praktijk te brengen

​Gerelateerde pagina’s

Introductie tot testen

Introductie

Requests maken

Requestheaders aanpassen

Cookies

Sessie en authenticatie

Responses debuggen

Excepties testen

JSON-API’s testen

Assertions op exacte overeenkomst

Assertions op JSON-paden

Fluente JSON-tests

Assertions op JSON-collecties

Assertions op JSON-types

Authenticatietests

Voorbeeld: de registratieflow testen

Sessies testen

Overzicht van sessie-assertions

Bestandsuploads testen

Dummybestanden aanpassen

Views testen

Componenten testen

Overzicht van response-assertions

HTTP-status

Redirects

Content

JSON

Headers en cookies

Views

Validatie

Tips om TDD in de praktijk te brengen

Gerelateerde pagina’s