Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Testing HTTP

Introduzione

Laravel offre un’API molto fluida per effettuare richieste HTTP alla tua applicazione ed esaminare le risposte. Ad esempio, dai un’occhiata al test delle funzionalità definito di seguito:

<?php

test('the application returns a successful response', function () {
    $response = $this->get('/');

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_the_application_returns_a_successful_response(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

Il metodo get effettua una richiesta GET all’interno dell’applicazione, mentre il metodo assertStatus verifica che la risposta restituita abbia il codice di stato HTTP dato. Oltre a questa semplice verifica, Laravel include una varietà di asserzioni per ispezionare gli header della risposta, il contenuto, la struttura JSON e altro ancora.

Effettuare Richieste

Per effettuare una richiesta alla tua applicazione, puoi utilizzare i metodi get, post, put, patch o delete all’interno del tuo test. Questi metodi non inviano effettivamente una richiesta HTTP "reale" alla tua applicazione. Invece, l’intera richiesta di rete viene simulata internamente.

Invece di restituire un’istanza di Illuminate\Http\Response, i metodi di richiesta nei test restituiscono un’istanza di Illuminate\Testing\TestResponse, che fornisce una varietà di asserzioni utili che ti permettono di esaminare le risposte della tua applicazione:

<?php

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

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Un esempio di test di base.
     */
    public function test_a_basic_request(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

In generale, ogni test dovrebbe effettuare solo una richiesta alla tua applicazione. Potrebbero verificarsi comportamenti imprevisti se vengono eseguite più richieste all’interno di un singolo metodo di test.

Per comodità, il middleware CSRF è disabilitato automaticamente durante l’esecuzione dei test.

Personalizzare le Intestazioni delle Richieste

Puoi usare il metodo withHeaders per personalizzare le intestazioni della richiesta prima che venga inviata all’applicazione. Questo metodo ti permette di aggiungere qualsiasi intestazione personalizzata desideri alla richiesta:

<?php

test('interacting with 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
{
    /**
     * Un esempio di test funzionale di base.
     */
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

Cookies

Puoi utilizzare i metodi withCookie o withCookies per impostare i valori dei cookie prima di effettuare una richiesta. Il metodo withCookie accetta il nome e il valore di un cookie come due argomenti, mentre il metodo withCookies accetta un array di coppie nome/valore:

<?php

test('interacting with 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('/');

        //
    }
}

Sessione / Autenticazione

Laravel fornisce diversi helper per interagire con la sessione durante i test HTTP. Prima di tutto, puoi impostare i dati della sessione a un array specifico usando il metodo withSession. Questo è utile per caricare la sessione con dati prima di effettuare una richiesta alla tua applicazione:

<?php

test('interacting with the session', 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('/');

        //
    }
}

La sessione di Laravel viene tipicamente utilizzata per mantenere lo stato dell’utente attualmente autenticato. Pertanto, il metodo helper actingAs fornisce un modo semplice per autenticare un determinato utente come utente corrente. Ad esempio, possiamo usare una factory di modelli per generare e autenticare un utente:

<?php

use App\Models\User;

test('an action that requires authentication', 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('/');

        //
    }
}

Puoi anche specificare quale guardia deve essere utilizzata per autenticare l’utente fornito passando il nome della guardia come secondo argomento al metodo actingAs. La guardia fornita al metodo actingAs diventerà anche la guardia predefinita per tutta la durata del test:

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

Debug delle Risposte

Dopo aver effettuato una richiesta di test alla tua applicazione, i metodi dump, dumpHeaders e dumpSession possono essere utilizzati per esaminare e debuggarne il contenuto della risposta:

<?php

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

    $response->dumpHeaders();

    $response->dumpSession();

    $response->dump();
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Un esempio di test di base.
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');

        $response->dumpHeaders();

        $response->dumpSession();

        $response->dump();
    }
}

In alternativa, puoi usare i metodi dd, ddHeaders e ddSession per stampare le informazioni sulla risposta e poi fermare l’esecuzione:

<?php

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

    $response->ddHeaders();

    $response->ddSession();

    $response->dd();
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Un esempio di test di base.
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');

        $response->ddHeaders();

        $response->ddSession();

        $response->dd();
    }
}

Gestione delle Eccezioni

A volte potresti aver bisogno di verificare che la tua applicazione lanci una specifica eccezione. Per fare ciò, puoi "falsificare" il gestore delle eccezioni tramite il facade Exceptions. Una volta falsificato il gestore delle eccezioni, puoi utilizzare i metodi assertReported e assertNotReported per fare delle asserzioni sulle eccezioni che sono state lanciate durante la richiesta:

<?php

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

test('exception is thrown', function () {
    Exceptions::fake();

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

    // Assert an exception was thrown...
    Exceptions::assertReported(InvalidOrderException::class);

    // Assert against the exception...
    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
{
    /**
     * Un esempio di test di base.
     */
    public function test_exception_is_thrown(): void
    {
        Exceptions::fake();

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

        // Assert an exception was thrown...
        Exceptions::assertReported(InvalidOrderException::class);

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

I metodi assertNotReported e assertNothingReported possono essere utilizzati per verificare che una determinata eccezione non sia stata lanciata durante la richiesta o che nessuna eccezione sia stata lanciata:

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

Puoi disabilitare completamente la gestione delle eccezioni per una determinata richiesta invocando il metodo withoutExceptionHandling prima di effettuare la tua richiesta:

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

Inoltre, se desideri assicurarti che la tua applicazione non utilizzi funzionalità deprecate dal linguaggio PHP o dalle librerie che la tua applicazione utilizza, puoi invocare il metodo withoutDeprecationHandling prima di effettuare la tua richiesta. Quando la gestione delle deprecazioni è disabilitata, gli avvisi di deprecazione verranno convertiti in eccezioni, causando così il fallimento del tuo test:

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

Il metodo assertThrows può essere utilizzato per verificare che un determinato blocco di codice lanci un’eccezione del tipo specificato:

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

Se desideri ispezionare e fare delle asserzioni sull’eccezione lanciata, puoi fornire una closure come secondo argomento al metodo assertThrows:

$this->assertThrows(
    fn () => (new ProcessOrder)->execute(),
    fn (OrderInvalid $e) => $e->orderId() === 123;
);

Test delle API JSON

Laravel fornisce anche diversi helper per testare le API JSON e le loro risposte. Ad esempio, i metodi json, getJson, postJson, putJson, patchJson, deleteJson e optionsJson possono essere usati per inviare richieste JSON con vari verbi HTTP. Puoi anche passare facilmente dati e intestazioni a questi metodi. Per iniziare, scriviamo un test per effettuare una richiesta POST a /api/user e verificare che i dati JSON attesi siano stati restituiti:

<?php

test('making an api request', 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
{
    /**
     * Un esempio di test funzionale di base.
     */
    public function test_making_an_api_request(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);

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

Inoltre, i dati della risposta JSON possono essere accessi come variabili array sulla risposta, rendendo comodo ispezionare i singoli valori restituiti all’interno di una risposta JSON:

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

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

Il metodo assertJson converte la risposta in un array per verificare che l’array dato esista all’interno della risposta JSON restituita dall’applicazione. Quindi, se ci sono altre proprietà nella risposta JSON, questo test passerà comunque fintanto che il frammento dato è presente.

Verificare Esattamente le Corrispondenze JSON

Come menzionato in precedenza, il metodo assertJson può essere utilizzato per verificare che un frammento di JSON esista all’interno della risposta JSON. Se desideri controllare che un array corrisponda esattamente al JSON restituito dalla tua applicazione, dovresti usare il metodo assertExactJson:

<?php

test('asserting an exact json match', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Un esempio di test funzionale di base.
     */
    public function test_asserting_an_exact_json_match(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

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

Verificare i percorsi JSON

Se vuoi controllare che la risposta JSON contenga determinati dati in un percorso specifico, usa il metodo assertJsonPath:

<?php

test('asserting a json path value', 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
{
    /**
     * Un esempio di test funzionale di base.
     */
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

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

Il metodo assertJsonPath accetta anche una closure, che può essere utilizzata per determinare dinamicamente se l’asserzione deve passare:

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

Test Fluent di JSON

Laravel offre anche un modo semplice per testare fluentemente le risposte JSON della tua applicazione. Per iniziare, passa una closure al metodo assertJson. Questa closure verrà invocata con un’istanza di Illuminate\Testing\Fluent\AssertableJson che può essere utilizzata per effettuare asserzioni sul JSON restituito dalla tua applicazione. Il metodo where può essere usato per fare asserzioni su un attributo particolare del JSON, mentre il metodo missing può essere utilizzato per affermare che un attributo specifico è mancante nel JSON:

use Illuminate\Testing\Fluent\AssertableJson;

test('fluent json', 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('victoria@gmail.com'))
                 ->whereNot('status', 'pending')
                 ->missing('password')
                 ->etc()
        );
});

use Illuminate\Testing\Fluent\AssertableJson;

/**
 * Un esempio di test funzionale di base.
 */
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('victoria@gmail.com'))
                 ->whereNot('status', 'pending')
                 ->missing('password')
                 ->etc()
        );
}

Comprendere il metodo etc

Nell’esempio sopra, potresti aver notato che abbiamo invocato il metodo etc alla fine della nostra catena di asserzioni. Questo metodo informa Laravel che potrebbero esserci altri attributi presenti nell’oggetto JSON. Se il metodo etc non viene utilizzato, il test fallirà se esistono altri attributi nell’oggetto JSON su cui non hai fatto asserzioni.

L’intento di questo comportamento è proteggerti dall’esposizione involontaria di informazioni sensibili nelle tue risposte JSON, costringendoti a fare esplicitamente un’asserzione sull’attributo o a permettere esplicitamente attributi aggiuntivi tramite il metodo etc.

Tuttavia, devi essere consapevole che non includere il metodo etc nella tua catena di asserzioni non garantisce che non vengano aggiunti attributi aggiuntivi agli array annidati all’interno del tuo oggetto JSON. Il metodo etc assicura solo che non esistano attributi aggiuntivi al livello di annidamento in cui viene invocato.

Verificare la Presenza / Assenza di Attributi

Per verificare che un attributo sia presente o assente, puoi usare i metodi has e missing:

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

Inoltre, i metodi hasAll e missingAll permettono di verificare la presenza o l’assenza di più attributi contemporaneamente:

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

Puoi usare il metodo hasAny per determinare se almeno uno degli attributi di una lista è presente:

    $response->assertJson(fn (AssertableJson $json) =>
        $json->has('status')
             ->hasAny('data', 'message', 'code')
    );

Verificare Collezioni JSON

Spesso, una tua route restituisce una risposta JSON con più elementi, ad esempio più utenti:

Route::get('/users', function () {
    return User::all();
});

In questi casi, possiamo usare il metodo has dell’oggetto JSON fluente per fare asserzioni sugli utenti presenti nella risposta. Ad esempio, verifichiamo che la risposta JSON contenga tre utenti. Successivamente, faremo alcune asserzioni sul primo utente della collezione usando il metodo first. Il metodo first accetta una closure che riceve un’altra stringa JSON asseribile, che possiamo usare per fare asserzioni sul primo oggetto nella collezione JSON:

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has(3)
             ->first(fn (AssertableJson $json) =>
                $json->where('id', 1)
                     ->where('name', 'Victoria Faith')
                     ->where('email', fn (string $email) => str($email)->is('victoria@gmail.com'))
                     ->missing('password')
                     ->etc()
             )
    );

Limitare le asserzioni sulle collezioni JSON

A volte, le rotte della tua applicazione restituiscono collezioni JSON con chiavi assegnate:

Route::get('/users', function () {
    return [
        'meta' => [...],
        'users' => User::all(),
    ];
})

Quando testi queste rotte, puoi usare il metodo has per verificare il numero di elementi nella collezione. Inoltre, puoi usare il metodo has per limitare una catena di asserzioni:

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has('meta')
             ->has('users', 3)
             ->has('users.0', fn (AssertableJson $json) =>
                $json->where('id', 1)
                     ->where('name', 'Victoria Faith')
                     ->where('email', fn (string $email) => str($email)->is('victoria@gmail.com'))
                     ->missing('password')
                     ->etc()
             )
    );

Tuttavia, invece di fare due chiamate separate al metodo has per verificare la collezione users, puoi fare una sola chiamata che fornisce una closure come terzo parametro. In questo modo, la closure verrà automaticamente invocata e limitata al primo elemento della collezione:

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has('meta')
             ->has('users', 3, fn (AssertableJson $json) =>
                $json->where('id', 1)
                     ->where('name', 'Victoria Faith')
                     ->where('email', fn (string $email) => str($email)->is('victoria@gmail.com'))
                     ->missing('password')
                     ->etc()
             )
    );

Asserzione dei Tipi JSON

Potresti voler verificare solo che le proprietà nella risposta JSON siano di un certo tipo. La classe Illuminate\Testing\Fluent\AssertableJson fornisce i metodi whereType e whereAllType per fare proprio questo:

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

Puoi specificare più tipi usando il carattere |, oppure passando un array di tipi come secondo parametro al metodo whereType. L’asserzione avrà successo se il valore della risposta è uno dei tipi elencati:

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

I metodi whereType e whereAllType riconoscono i seguenti tipi: string, integer, double, boolean, array e null.

Testare il caricamento di file

La classe Illuminate\Http\UploadedFile fornisce un metodo fake che può essere utilizzato per generare file o immagini fittizi per il testing. Questo, combinato con il metodo fake del facade Storage, semplifica notevolmente i test di caricamento dei file. Ad esempio, puoi combinare queste due funzionalità per testare facilmente un modulo di caricamento dell’avatar:

<?php

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

test('avatars can be uploaded', 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 ExampleTest 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());
    }
}

Se desideri verificare che un determinato file non esista, puoi utilizzare il metodo assertMissing fornito dal facade Storage:

    Storage::fake('avatars');

    // ...

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

Personalizzazione di File Fake

Quando crei file usando il metodo fake fornito dalla classe UploadedFile, puoi specificare la larghezza, l’altezza e la dimensione dell’immagine (in kilobyte) per testare meglio le regole di validazione della tua applicazione:

UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);

Oltre a creare immagini, puoi creare file di qualsiasi altro tipo usando il metodo create:

UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);

Se necessario, puoi passare un argomento $mimeType al metodo per definire esplicitamente il tipo MIME che il file dovrebbe restituire:

UploadedFile::fake()->create(
    'document.pdf', $sizeInKilobytes, 'application/pdf'
);

Testing Views

Laravel permette anche di renderizzare una view senza effettuare una richiesta HTTP simulata all’applicazione. Per fare ciò, puoi chiamare il metodo view all’interno del tuo test. Il metodo view accetta il nome della view e un array opzionale di dati. Il metodo restituisce un’istanza di Illuminate\Testing\TestView, che offre diversi metodi per effettuare facilmente asserzioni sul contenuto della view:

<?php

test('a welcome view can be rendered', function () {
    $view = $this->view('welcome', ['name' => 'Taylor']);

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

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

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

La classe TestView fornisce i seguenti metodi di asserzione: assertSee, assertSeeInOrder, assertSeeText, assertSeeTextInOrder, assertDontSee e assertDontSeeText.

Se necessario, puoi ottenere il contenuto grezzo e renderizzato della view convertendo l’istanza di TestView in una stringa:

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

Condivisione degli errori

Alcune viste potrebbero dipendere dagli errori condivisi nel global error bag fornito da Laravel. Per popolare l’error bag con i messaggi di errore, puoi usare il metodo withViewErrors:

$view = $this->withViewErrors([
    'name' => ['Please provide a valid name.']
])->view('form');

$view->assertSee('Please provide a valid name.');

Rendering Blade e Componenti

Se necessario, puoi usare il metodo blade per valutare e renderizzare una stringa Blade grezza. Come il metodo view, il metodo blade restituisce una istanza di Illuminate\Testing\TestView:

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

    $view->assertSee('Taylor');

Puoi usare il metodo component per valutare e renderizzare un Blade component. Il metodo component restituisce una istanza di Illuminate\Testing\TestComponent:

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

    $view->assertSee('Taylor');

Asserzioni Disponibili

Assert di Risposta

La classe Illuminate\Testing\TestResponse di Laravel fornisce una varietà di metodi di assert personalizzati che puoi utilizzare quando testi la tua applicazione. Questi assert possono essere utilizzati sulla risposta restituita dai metodi di test json, get, post, put e delete:

assertBadRequest

Verifica che la risposta abbia un codice di stato HTTP bad request (400):

$response->assertBadRequest();

assertAccepted

Verifica che la risposta abbia lo stato HTTP accepted (202):

$response->assertAccepted();

assertConflict

Verifica che la risposta abbia il codice di stato HTTP 409 (conflitto):

$response->assertConflict();

assertCookie

Verifica che la risposta contenga il cookie indicato:

$response->assertCookie($cookieName, $value = null);

assertCookieExpired

Verifica che la risposta contenga il cookie specificato e che sia scaduto:

    $response->assertCookieExpired($cookieName);

assertCookieNotExpired

Verifica che la risposta contenga il cookie specificato e che non sia scaduto:

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

Verifica che la risposta non contenga il cookie specificato:

$response->assertCookieMissing($cookieName);

assertCreated

Verifica che la risposta abbia un codice di stato HTTP 201:

$response->assertCreated();

assertDontSee

Verifica che la stringa fornita non sia presente nella risposta restituita dall’applicazione. Questa asserzione eseguirà automaticamente l’escape della stringa a meno che non passi un secondo argomento con valore false:

$response->assertDontSee($value, $escaped = true);

assertDontSeeText

Verifica che la stringa fornita non sia presente nel testo della risposta. Questa asserzione scapperà automaticamente la stringa a meno che non passi un secondo argomento false. Questo metodo passa il contenuto della risposta alla funzione PHP strip_tags prima di effettuare l’asserzione:

    $response->assertDontSeeText($value, $escaped = true);

assertDownload

Verifica che la risposta sia un "download". Di solito, ciò significa che la rotta invocata che ha restituito la risposta ha restituito una Response::download, BinaryFileResponse o Storage::download:

    $response->assertDownload();

Se vuoi, puoi verificare che il file scaricabile abbia ricevuto un determinato nome:

    $response->assertDownload('image.jpg');

assertExactJson

Verifica che la risposta contenga una corrispondenza esatta dei dati JSON forniti:

$response->assertExactJson(array $data);

assertExactJsonStructure

Asserisci che la risposta contenga una corrispondenza esatta della struttura JSON fornita:

$response->assertExactJsonStructure(array $data);

Questo metodo è una variante più rigorosa di assertJsonStructure. A differenza di assertJsonStructure, questo metodo fallirà se la risposta contiene chiavi che non sono esplicitamente incluse nella struttura JSON prevista.

assertForbidden

Verifica che la risposta abbia un codice di stato HTTP proibito (403):

    $response->assertForbidden();

assertFound

Verifica che la risposta abbia un codice di stato HTTP found (302):

$response->assertFound();

assertGone

Verifica che la risposta abbia un codice di stato HTTP "gone" (410):

$response->assertGone();

assertHeader

Verifica che l’header e il valore specificati siano presenti nella risposta:

$response->assertHeader($headerName, $value = null);

assertHeaderMissing

Verifica che l’intestazione specificata non sia presente nella risposta:

$response->assertHeaderMissing($headerName);

assertInternalServerError

Verifica che la risposta abbia un codice di stato HTTP "Internal Server Error" (500):

    $response->assertInternalServerError();

assertJson

Verifica che la risposta contenga i dati JSON specificati:

$response->assertJson(array $data, $strict = false);

Il metodo assertJson converte la risposta in un array per verificare che l’array fornito esista all’interno della risposta JSON restituita dall’applicazione. Quindi, se ci sono altre proprietà nella risposta JSON, questo test passerà comunque a condizione che il frammento fornito sia presente.

assertJsonCount

Verifica che il JSON della risposta contenga un array con il numero previsto di elementi alla chiave specificata:

$response->assertJsonCount($count, $key = null);

assertJsonFragment

Verifica che la risposta contenga i dati JSON specificati in qualsiasi parte della risposta:

Route::get('/users', function () {
    return [
        'users' => [
            [
                'name' => 'Taylor Otwell',
            ],
        ],
    ];
});

$response->assertJsonFragment(['name' => 'Taylor Otwell']);

assertJsonIsArray

Verifica che il JSON della risposta sia un array:

$response->assertJsonIsArray();

assertJsonIsObject

Verifica che il JSON della risposta sia un oggetto:

$response->assertJsonIsObject();

assertJsonMissing

Verifica che la risposta non includa i dati JSON forniti:

$response->assertJsonMissing(array $data);

assertJsonMissingExact

Verifica che la risposta non contenga esattamente i dati JSON:

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

Verifica che la risposta non abbia errori di validazione JSON per le chiavi specificate:

$response->assertJsonMissingValidationErrors($keys);

Il metodo più generico assertValid può essere usato per verificare che una risposta non abbia errori di validazione restituiti come JSON e che nessun errore sia stato salvato nella sessione.

assertJsonPath

Verifica che la risposta contenga i dati specificati nel percorso indicato:

    $response->assertJsonPath($path, $expectedValue);

Ad esempio, se la tua applicazione restituisce la seguente risposta JSON:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puoi verificare che la proprietà name dell’oggetto user corrisponda a un valore specifico in questo modo:

    $response->assertJsonPath('user.name', 'Steve Schoger');

assertJsonMissingPath

Verifica che la risposta non contenga il percorso specificato:

    $response->assertJsonMissingPath($path);

Per esempio, se la tua applicazione restituisce la seguente risposta JSON:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puoi verificare che non contenga la proprietà email dell’oggetto user:

    $response->assertJsonMissingPath('user.email');

assertJsonStructure

Verifica che la risposta abbia una determinata struttura JSON:

    $response->assertJsonStructure(array $structure);

Ad esempio, se la risposta JSON restituita dalla tua applicazione contiene i seguenti dati:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puoi verificare che la struttura JSON corrisponda alle tue aspettative in questo modo:

    $response->assertJsonStructure([
        'user' => [
            'name',
        ]
    ]);

A volte, le risposte JSON restituite dalla tua applicazione possono contenere array di oggetti:

{
    "user": [
        {
            "name": "Steve Schoger",
            "age": 55,
            "location": "Earth"
        },
        {
            "name": "Mary Schoger",
            "age": 60,
            "location": "Earth"
        }
    ]
}

In questa situazione, puoi usare il carattere * per verificare la struttura di tutti gli oggetti nell’array:

    $response->assertJsonStructure([
        'user' => [
            '*' => [
                 'name',
                 'age',
                 'location'
            ]
        ]
    ]);

assertJsonValidationErrors

Assicurati che la risposta contenga gli errori di validazione JSON specificati per le chiavi date. Questo metodo va utilizzato quando si verificano risposte in cui gli errori di validazione vengono restituiti come struttura JSON invece di essere memorizzati nella sessione:

$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');

Il metodo più generico assertInvalid può essere usato per verificare che una risposta contenga errori di validazione restituiti come JSON o che gli errori siano stati memorizzati nella sessione.

assertJsonValidationErrorFor

Controlla che la risposta contenga errori di validazione JSON per la chiave specificata:

$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');

assertMethodNotAllowed

Verifica che la risposta abbia un codice di stato HTTP metodo non consentito (405):

$response->assertMethodNotAllowed();

assertMovedPermanently

Verifica che la risposta abbia un codice di stato HTTP spostato permanentemente (301):

$response->assertMovedPermanently();

assertLocation

Verifica che la risposta contenga il valore URI specificato nell’intestazione Location:

$response->assertLocation($uri);

assertContent

Verifica che la stringa fornita corrisponda al contenuto della risposta:

$response->assertContent($value);

assertNoContent

Verifica che la risposta abbia il codice di stato HTTP specificato e nessun contenuto:

$response->assertNoContent($status = 204);

assertStreamedContent

Verifica che la stringa fornita corrisponda al contenuto della risposta in streaming:

$response->assertStreamedContent($value);

assertNotFound

Verifica che la risposta abbia un codice di stato HTTP non trovato (404):

$response->assertNotFound();

assertOk

Verifica che la risposta abbia un codice di stato HTTP 200:

$response->assertOk();

assertPaymentRequired

Verifica che la risposta abbia un codice di stato HTTP "Pagamento Richiesto" (402):

$response->assertPaymentRequired();

assertPlainCookie

Verifica che la risposta contenga il cookie non criptato specificato:

$response->assertPlainCookie($cookieName, $value = null);

assertRedirect

Verifica che la risposta sia un redirect all’URI fornito:

$response->assertRedirect($uri = null);

assertRedirectContains

Controlla se la risposta reindirizza a un URI che include la stringa specificata:

$response->assertRedirectContains($string);

assertRedirectToRoute

Verifica che la risposta sia un reindirizzamento alla named route specificata:

$response->assertRedirectToRoute($name, $parameters = []);

assertRedirectToSignedRoute

Verifica che la risposta sia un reindirizzamento alla signed route specificata:

$response->assertRedirectToSignedRoute($name = null, $parameters = []);

assertRequestTimeout

Verifica che la risposta abbia un codice di stato HTTP di timeout della richiesta (408):

$response->assertRequestTimeout();

assertSee

Controlla che la stringa fornita sia presente nella risposta. Questa verifica eseguirà automaticamente l’escape della stringa a meno che non passi un secondo argomento false:

$response->assertSee($value, $escaped = true);

assertSeeInOrder

Verifica che le stringhe fornite siano presenti nell’ordine corretto nella risposta. Questa asserzione effettuerà automaticamente l’escape delle stringhe, a meno che non passi un secondo argomento di false:

$response->assertSeeInOrder(array $values, $escaped = true);

assertSeeText

Verifica che la stringa fornita sia presente nel testo della risposta. Questa asserzione esegue automaticamente l’escape della stringa, a meno che non passi un secondo argomento come false. Il contenuto della risposta viene passato alla funzione PHP strip_tags prima di effettuare l’asserzione:

$response->assertSeeText($value, $escaped = true);

assertSeeTextInOrder

Verifica che le stringhe fornite siano presenti nell’ordine nel testo della risposta. Questa asserzione esegue automaticamente l’escape delle stringhe a meno che non passi un secondo argomento di false. Il contenuto della risposta verrà passato alla funzione PHP strip_tags prima che l’asserzione venga eseguita:

$response->assertSeeTextInOrder(array $values, $escaped = true);

assertServerError

Verifica che la risposta abbia un codice di stato HTTP di errore server (>= 500 e < 600):

$response->assertServerError();

assertServiceUnavailable

Verifica che la risposta abbia un codice di stato HTTP "Servizio non disponibile" (503):

$response->assertServiceUnavailable();

assertSessionHas

Verifica che la sessione contenga il dato specificato:

$response->assertSessionHas($key, $value = null);

Se necessario, puoi fornire una closure come secondo argomento al metodo assertSessionHas. L’asserzione avrà successo se la closure restituisce true:

$response->assertSessionHas($key, function (User $value) {
    return $value->name === 'Taylor Otwell';
});

assertSessionHasInput

Verifica che la sessione contenga un determinato valore nell’ array di input flashed:

$response->assertSessionHasInput($key, $value = null);

Se necessario, puoi fornire una closure come secondo argomento al metodo assertSessionHasInput. L’asserzione sarà valida se la closure restituisce true:

use Illuminate\Support\Facades\Crypt;

$response->assertSessionHasInput($key, function (string $value) {
    return Crypt::decryptString($value) === 'secret';
});

assertSessionHasAll

Verifica che la sessione contenga un array specificato di coppie chiave/valore:

$response->assertSessionHasAll(array $data);

Ad esempio, se la sessione della tua applicazione contiene le chiavi name e status, puoi verificare che entrambe esistano e abbiano i valori specificati in questo modo:

$response->assertSessionHasAll([
    'name' => 'Taylor Otwell',
    'status' => 'active',
]);

assertSessionHasErrors

Verifica che la sessione contenga un errore per le $keys fornite. Se $keys è un array associativo, verifica che la sessione contenga un messaggio di errore specifico (valore) per ogni campo (chiave). Questo metodo dovrebbe essere usato quando si testano le rotte che inviano errori di validazione alla sessione anziché restituirli come struttura JSON:

    $response->assertSessionHasErrors(
        array $keys = [], $format = null, $errorBag = 'default'
    );

Ad esempio, per verificare che i campi name ed email abbiano messaggi di errore di validazione inviati alla sessione, puoi chiamare il metodo assertSessionHasErrors così:

    $response->assertSessionHasErrors(['name', 'email']);

Oppure, puoi verificare che un determinato campo abbia un particolare messaggio di errore di validazione:

    $response->assertSessionHasErrors([
        'name' => 'The given name was invalid.'
    ]);

Il metodo più generico assertInvalid può essere usato per verificare che una risposta abbia errori di validazione restituiti come JSON o che gli errori siano stati inviati alla sessione.

assertSessionHasErrorsIn

Verifica che la sessione contenga un errore per le $keys specificate all’interno di uno error bag. Se $keys è un array associativo, controlla che la sessione abbia un messaggio di errore specifico (valore) per ogni campo (chiave) all’interno dell’error bag:

    $response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);

assertSessionHasNoErrors

Verifica che la sessione non abbia errori di validazione:

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

Verifica che la sessione non abbia errori di validazione per le chiavi fornite:

    $response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');

Il metodo più generico assertValid può essere utilizzato per verificare che una risposta non abbia errori di validazione restituiti come JSON e che nessun errore sia stato memorizzato nella sessione.

assertSessionMissing

Verifica che la sessione non contenga la chiave specificata:

$response->assertSessionMissing($key);

assertStatus

Verifica che la risposta abbia un determinato codice di stato HTTP:

$response->assertStatus($code);

assertSuccessful

Verifica che la risposta abbia un codice di stato HTTP di successo (>= 200 e < 300):

$response->assertSuccessful();

assertTooManyRequests

Verifica che la risposta abbia lo status code HTTP "too many requests" (429):

$response->assertTooManyRequests();

assertUnauthorized

Verifica che la risposta abbia un codice di stato HTTP non autorizzato (401):

$response->assertUnauthorized();

assertUnprocessable

Verifica che la risposta abbia un codice di stato HTTP "unprocessable entity" (422):

$response->assertUnprocessable();

assertUnsupportedMediaType

Verifica che la risposta abbia un tipo di media non supportato (codice di stato HTTP 415):

$response->assertUnsupportedMediaType();

assertValid

Verifica che la risposta non abbia errori di validazione per le chiavi specificate. Questo metodo può essere usato per verificare risposte in cui gli errori di validazione sono restituiti come struttura JSON o dove gli errori di validazione sono stati salvati nella sessione:

// Verifica che non ci siano errori di validazione...
$response->assertValid();

// Verifica che le chiavi specificate non abbiano errori di validazione...
$response->assertValid(['name', 'email']);

assertInvalid

Verifica che la risposta contenga errori di validazione per le chiavi specificate. Questo metodo può essere utilizzato per controllare risposte in cui gli errori di validazione vengono restituiti come struttura JSON o quando sono stati salvati nella sessione:

    $response->assertInvalid(['name', 'email']);

Puoi anche verificare che una determinata chiave abbia un messaggio di errore di validazione specifico. In questo caso, puoi fornire l’intero messaggio o solo una parte:

    $response->assertInvalid([
        'name' => 'The name field is required.',
        'email' => 'valid email address',
    ]);

assertViewHas

Verifica che la vista della risposta contenga un determinato dato:

$response->assertViewHas($key, $value = null);

Passare una closure come secondo argomento al metodo assertViewHas ti permette di ispezionare e fare asserzioni su un particolare dato della vista:

$response->assertViewHas('user', function (User $user) {
    return $user->name === 'Taylor';
});

Inoltre, i dati della vista possono essere accessibili come variabili array sulla risposta, permettendoti di ispezionarli comodamente:

php tab=Pest
expect($response['name'])->toBe('Taylor');

tab=PHPUnit
$this->assertEquals('Taylor', $response['name']);

assertViewHasAll

Verifica che la view della risposta contenga una lista specificata di dati:

$response->assertViewHasAll(array $data);

Questo metodo può essere utilizzato per verificare che la view contenga semplicemente dati corrispondenti alle chiavi specificate:

$response->assertViewHasAll([
    'name',
    'email',
]);

Oppure, puoi verificare che i dati della view siano presenti e abbiano valori specifici:

$response->assertViewHasAll([
    'name' => 'Taylor Otwell',
    'email' => 'taylor@example.com,',
]);

assertViewIs

Assicurati che la vista specificata sia stata restituita dalla route:

$response->assertViewIs($value);

assertViewMissing

Verifica che la chiave dei dati specificata non sia disponibile nella vista restituita dalla risposta dell’applicazione:

$response->assertViewMissing($key);

Assunzioni di Autenticazione

Laravel fornisce anche una varietà di asserzioni relative all’autenticazione che puoi utilizzare nei test delle funzionalità della tua applicazione. Nota che questi metodi vengono invocati direttamente sulla classe di test e non sull’istanza Illuminate\Testing\TestResponse restituita da metodi come get e post.

assertAuthenticated

Verifica se un utente è autenticato:

$this->assertAuthenticated($guard = null);

assertGuest

Verifica che un utente non sia autenticato:

$this->assertGuest($guard = null);

assertAuthenticatedAs

Verifica che un utente specifico sia autenticato:

$this->assertAuthenticatedAs($user, $guard = null);

Affermazioni di Validazione

Laravel offre due principali affermazioni relative alla validazione che puoi usare per assicurarti che i dati forniti nella tua richiesta siano validi o invalidi.

assertValid

Verifica che la risposta non abbia errori di validazione per le chiavi specificate. Questo metodo può essere usato per controllare risposte dove gli errori di validazione sono restituiti come struttura JSON o dove gli errori di validazione sono stati memorizzati nella sessione:

// Verifica che non siano presenti errori di validazione...
$response->assertValid();

// Verifica che le chiavi specificate non abbiano errori di validazione...
$response->assertValid(['name', 'email']);

assertInvalid

Verifica che la risposta contenga errori di validazione per le chiavi specificate. Questo metodo può essere utilizzato per controllare risposte in cui gli errori di validazione vengono restituiti come struttura JSON o in cui gli errori di validazione sono stati salvati nella sessione:

$response->assertInvalid(['name', 'email']);

Puoi anche verificare che una determinata chiave abbia un messaggio di errore di validazione specifico. In questo caso, puoi fornire l’intero messaggio o solo una parte del messaggio:

$response->assertInvalid([
    'name' => 'The name field is required.',
    'email' => 'valid email address',
]);
Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia