Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Client HTTP

Introduzione

Laravel offre un’API espressiva e minimale intorno al Guzzle HTTP client, permettendoti di effettuare rapidamente richieste HTTP in uscita per comunicare con altre applicazioni web. Il wrapper di Laravel per Guzzle è focalizzato sui casi d’uso più comuni e fornisce un’eccellente esperienza per gli sviluppatori.

Effettuare Richieste

Per fare richieste, puoi usare i metodi head, get, post, put, patch e delete forniti dal facade Http. Innanzitutto, vediamo come effettuare una richiesta GET di base a un altro URL:

    use Illuminate\Support\Facades\Http;

    $response = Http::get('http://example.com');

Il metodo get restituisce un’istanza di Illuminate\Http\Client\Response, che offre vari metodi per esaminare la risposta:

    $response->body() : string;
    $response->json($key = null, $default = null) : mixed;
    $response->object() : object;
    $response->collect($key = null) : Illuminate\Support\Collection;
    $response->resource() : resource;
    $response->status() : int;
    $response->successful() : bool;
    $response->redirect(): bool;
    $response->failed() : bool;
    $response->clientError() : bool;
    $response->header($header) : string;
    $response->headers() : array;

L’oggetto Illuminate\Http\Client\Response implementa anche l’interfaccia PHP ArrayAccess, permettendoti di accedere direttamente ai dati JSON della risposta:

    return Http::get('http://example.com/users/1')['name'];

Oltre ai metodi di risposta elencati sopra, puoi utilizzare i seguenti metodi per verificare se la risposta ha un determinato codice di stato:

    $response->ok() : bool;                  // 200 OK
    $response->created() : bool;             // 201 Created
    $response->accepted() : bool;            // 202 Accepted
    $response->noContent() : bool;           // 204 No Content
    $response->movedPermanently() : bool;    // 301 Moved Permanently
    $response->found() : bool;               // 302 Found
    $response->badRequest() : bool;          // 400 Bad Request
    $response->unauthorized() : bool;        // 401 Unauthorized
    $response->paymentRequired() : bool;     // 402 Payment Required
    $response->forbidden() : bool;           // 403 Forbidden
    $response->notFound() : bool;            // 404 Not Found
    $response->requestTimeout() : bool;      // 408 Request Timeout
    $response->conflict() : bool;            // 409 Conflict
    $response->unprocessableEntity() : bool; // 422 Unprocessable Entity
    $response->tooManyRequests() : bool;     // 429 Too Many Requests
    $response->serverError() : bool;         // 500 Internal Server Error

Modelli URI

Il client HTTP consente anche di costruire URL di richiesta utilizzando la specifica del template URI. Per definire i parametri dell’URL che possono essere espansi dal tuo template URI, puoi usare il metodo withUrlParameters:

Http::withUrlParameters([
    'endpoint' => 'https://laravel.com',
    'page' => 'docs',
    'version' => '11.x',
    'topic' => 'validation',
])->get('{+endpoint}/{page}/{version}/{topic}');

Dumping delle Richieste

Se vuoi fare il dump dell’istanza della richiesta in uscita prima che venga inviata e terminare l’esecuzione dello script, puoi aggiungere il metodo dd all’inizio della definizione della tua richiesta:

return Http::dd()->get('http://example.com');

Dati della Richiesta

Certo, è comune quando si effettuano richieste POST, PUT e PATCH inviare dati aggiuntivi con la tua richiesta, quindi questi metodi accettano un array di dati come secondo argomento. Per default, i dati verranno inviati utilizzando il tipo di contenuto application/json:

use Illuminate\Support\Facades\Http;

$response = Http::post('http://example.com/users', [
    'name' => 'Steve',
    'role' => 'Network Administrator',
]);

Parametri della Query per le Richieste GET

Quando effettui richieste GET, puoi aggiungere direttamente una stringa di query all’URL oppure passare un array di coppie chiave/valore come secondo argomento al metodo get:

$response = Http::get('http://example.com/users', [
    'name' => 'Taylor',
    'page' => 1,
]);

In alternativa, puoi usare il metodo withQueryParameters:

Http::retry(3, 100)->withQueryParameters([
    'name' => 'Taylor',
    'page' => 1,
])->get('http://example.com/users')

Inviare richieste form URL encoded

Se vuoi inviare dati usando il tipo di contenuto application/x-www-form-urlencoded, devi chiamare il metodo asForm prima di effettuare la tua richiesta:

$response = Http::asForm()->post('http://example.com/users', [
    'name' => 'Sara',
    'role' => 'Privacy Consultant',
]);

Inviare un Body di Richiesta Grezzo

Puoi usare il metodo withBody se vuoi fornire un corpo di richiesta grezzo quando effettui una richiesta. Il tipo di contenuto può essere specificato come secondo argomento del metodo:

$response = Http::withBody(
    base64_encode($photo), 'image/jpeg'
)->post('http://example.com/photo');

Richieste Multi-Part

Se vuoi inviare file come richieste multi-part, devi chiamare il metodo attach prima di effettuare la tua richiesta. Questo metodo accetta il nome del file e il suo contenuto. Se necessario, puoi fornire un terzo argomento che sarà considerato come il nome del file, mentre un quarto argomento può essere usato per fornire le intestazioni associate al file:

    $response = Http::attach(
        'attachment', file_get_contents('photo.jpg'), 'photo.jpg', ['Content-Type' => 'image/jpeg']
    )->post('http://example.com/attachments');

Invece di passare il contenuto grezzo di un file, puoi passare una risorsa stream:

    $photo = fopen('photo.jpg', 'r');

    $response = Http::attach(
        'attachment', $photo, 'photo.jpg'
    )->post('http://example.com/attachments');

Headers

Gli headers possono essere aggiunti alle richieste usando il metodo withHeaders. Questo metodo withHeaders accetta un array di coppie chiave/valore:

$response = Http::withHeaders([
    'X-First' => 'foo',
    'X-Second' => 'bar'
])->post('http://example.com/users', [
    'name' => 'Taylor',
]);

Puoi usare il metodo accept per specificare il tipo di contenuto che la tua applicazione si aspetta in risposta alla tua richiesta:

$response = Http::accept('application/json')->get('http://example.com/users');

Per comodità, puoi usare il metodo acceptJson per specificare rapidamente che la tua applicazione si aspetta il tipo di contenuto application/json in risposta alla tua richiesta:

$response = Http::acceptJson()->get('http://example.com/users');

Il metodo withHeaders unisce i nuovi headers a quelli già presenti nella richiesta. Se necessario, puoi sostituire tutti gli headers utilizzando il metodo replaceHeaders:

$response = Http::withHeaders([
    'X-Original' => 'foo',
])->replaceHeaders([
    'X-Replacement' => 'bar',
])->post('http://example.com/users', [
    'name' => 'Taylor',
]);

Autenticazione

Puoi specificare le credenziali di autenticazione base e digest utilizzando rispettivamente i metodi withBasicAuth e withDigestAuth:

// Autenticazione base...
$response = Http::withBasicAuth('taylor@laravel.com', 'secret')->post(/* ... */);

// Autenticazione digest...
$response = Http::withDigestAuth('taylor@laravel.com', 'secret')->post(/* ... */);

Bearer Tokens

Se vuoi aggiungere rapidamente un bearer token all’header Authorization della richiesta, puoi usare il metodo withToken:

$response = Http::withToken('token')->post(/* ... */);

Timeout

Il metodo timeout può essere utilizzato per specificare il numero massimo di secondi da attendere per una risposta. Di default, il client HTTP scade dopo 30 secondi:

$response = Http::timeout(3)->get(/* ... */);

Se il timeout specificato viene superato, verrà lanciata un’istanza di Illuminate\Http\Client\ConnectionException.

Puoi specificare il numero massimo di secondi da attendere mentre tenti di connetterti a un server usando il metodo connectTimeout:

$response = Http::connectTimeout(3)->get(/* ... */);

Riprovare una Richiesta

Se desideri che il client HTTP tenti automaticamente nuovamente la richiesta in caso di errori client o server, puoi usare il metodo retry. Il metodo retry accetta il numero massimo di tentativi e il numero di millisecondi che Laravel deve attendere tra i tentativi:

$response = Http::retry(3, 100)->post(/* ... */);

Se preferisci calcolare manualmente il numero di millisecondi di attesa tra i tentativi, puoi passare una closure come secondo argomento al metodo retry:

use Exception;

$response = Http::retry(3, function (int $attempt, Exception $exception) {
    return $attempt * 100;
})->post(/* ... */);

Per comodità, puoi anche fornire un array come primo argomento al metodo retry. Questo array verrà utilizzato per determinare quanti millisecondi attendere tra i tentativi successivi:

$response = Http::retry([100, 200])->post(/* ... */);

Se necessario, puoi passare un terzo argomento al metodo retry. Il terzo argomento deve essere una callable che determina se tentare effettivamente i ritenti. Ad esempio, potresti voler ritentare la richiesta solo se la richiesta iniziale incontra una ConnectionException:

use Exception;
use Illuminate\Http\Client\PendingRequest;

$response = Http::retry(3, 100, function (Exception $exception, PendingRequest $request) {
    return $exception instanceof ConnectionException;
})->post(/* ... */);

Se un tentativo di richiesta fallisce, potresti voler modificare la richiesta prima di un nuovo tentativo. Puoi farlo modificando l’argomento della richiesta fornito alla callable passata al metodo retry. Ad esempio, potresti voler ritentare la richiesta con un nuovo token di autorizzazione se il primo tentativo ha restituito un errore di autenticazione:

use Exception;
use Illuminate\Http\Client\PendingRequest;
use Illuminate\Http\Client\RequestException;

$response = Http::withToken($this->getToken())->retry(2, 0, function (Exception $exception, PendingRequest $request) {
    if (! $exception instanceof RequestException || $exception->response->status() !== 401) {
        return false;
    }

    $request->withToken($this->getNewToken());

    return true;
})->post(/* ... */);

Se tutte le richieste falliscono, verrà lanciata un’istanza di Illuminate\Http\Client\RequestException. Se desideri disabilitare questo comportamento, puoi fornire un argomento throw con valore false. Quando disabilitato, l’ultima risposta ricevuta dal client verrà restituita dopo tutti i tentativi:

$response = Http::retry(3, 100, throw: false)->post(/* ... */);

Se tutte le richieste falliscono a causa di un problema di connessione, verrà comunque lanciata una Illuminate\Http\Client\ConnectionException anche quando l’argomento throw è impostato su false.

Gestione degli Errori

A differenza del comportamento predefinito di Guzzle, il wrapper del client HTTP di Laravel non lancia eccezioni per errori client o server (risposte di livello 400 e 500 dai server). Puoi determinare se è stato restituito uno di questi errori usando i metodi successful, clientError o serverError:

// Determina se il codice di stato è >= 200 e < 300...
$response->successful();

// Determina se il codice di stato è >= 400...
$response->failed();

// Determina se la risposta ha un codice di stato di livello 400...
$response->clientError();

// Determina se la risposta ha un codice di stato di livello 500...
$response->serverError();

// Esegue immediatamente il callback dato se c'è stato un errore client o server...
$response->onError(callable $callback);

Lancio delle Eccezioni

Se hai un’istanza di risposta e desideri lanciare un’istanza di Illuminate\Http\Client\RequestException se il codice di stato della risposta indica un errore client o server, puoi utilizzare i metodi throw o throwIf:

use Illuminate\Http\Client\Response;

$response = Http::post(/* ... */);

// Lancia un'eccezione se si verifica un errore client o server...
$response->throw();

// Lancia un'eccezione se si verifica un errore e la condizione data è vera...
$response->throwIf($condition);

// Lancia un'eccezione se si verifica un errore e la closure data restituisce true...
$response->throwIf(fn (Response $response) => true);

// Lancia un'eccezione se si verifica un errore e la condizione data è falsa...
$response->throwUnless($condition);

// Lancia un'eccezione se la risposta ha un codice di stato specifico...
$response->throwIfStatus(403);

// Lancia un'eccezione a meno che la risposta non abbia un codice di stato specifico...
$response->throwUnlessStatus(200);

return $response['user']['id'];

L’istanza di Illuminate\Http\Client\RequestException ha una proprietà pubblica $response che ti permette di ispezionare la risposta restituita.

Il metodo throw restituisce l’istanza della risposta se non si è verificato nessun errore, permettendoti di concatenare altre operazioni sul metodo throw:

return Http::post(/* ... */)->throw()->json();

Se desideri eseguire ulteriori logiche prima che l’eccezione venga lanciata, puoi passare una closure al metodo throw. L’eccezione verrà automaticamente lanciata dopo l’esecuzione della closure, quindi non è necessario rilanciare l’eccezione all’interno della closure:

use Illuminate\Http\Client\Response;
use Illuminate\Http\Client\RequestException;

return Http::post(/* ... */)->throw(function (Response $response, RequestException $e) {
    // ...
})->json();

Per impostazione predefinita, i messaggi di RequestException vengono troncati a 120 caratteri quando vengono registrati o segnalati. Per personalizzare o disabilitare questo comportamento, puoi utilizzare i metodi truncateRequestExceptionsAt e dontTruncateRequestExceptions quando configuri il comportamento di gestione delle eccezioni della tua applicazione nel file bootstrap/app.php:

->withExceptions(function (Exceptions $exceptions) {
    // Trunca i messaggi delle eccezioni di richiesta a 240 caratteri...
    $exceptions->truncateRequestExceptionsAt(240);

    // Disabilita la troncatura dei messaggi delle eccezioni di richiesta...
    $exceptions->dontTruncateRequestExceptions();
})

Guzzle Middleware

Poiché il client HTTP di Laravel è basato su Guzzle, puoi sfruttare Guzzle Middleware per manipolare la richiesta in uscita o esaminare la risposta in arrivo. Per modificare la richiesta in uscita, registra un middleware Guzzle tramite il metodo withRequestMiddleware:

use Illuminate\Support\Facades\Http;
use Psr\Http\Message\RequestInterface;

$response = Http::withRequestMiddleware(
    function (RequestInterface $request) {
        return $request->withHeader('X-Example', 'Value');
    }
)->get('http://example.com');

Allo stesso modo, puoi esaminare la risposta HTTP in arrivo registrando un middleware tramite il metodo withResponseMiddleware:

use Illuminate\Support\Facades\Http;
use Psr\Http\Message\ResponseInterface;

$response = Http::withResponseMiddleware(
    function (ResponseInterface $response) {
        $header = $response->getHeader('X-Example');

        // ...

        return $response;
    }
)->get('http://example.com');

Middleware Globale

A volte potrebbe essere necessario registrare un middleware che si applica a tutte le richieste in uscita e alle risposte in arrivo. Per fare ciò, puoi utilizzare i metodi globalRequestMiddleware e globalResponseMiddleware. Solitamente, questi metodi dovrebbero essere invocati nel metodo boot del AppServiceProvider della tua applicazione:

use Illuminate\Support\Facades\Http;

Http::globalRequestMiddleware(fn ($request) => $request->withHeader(
    'User-Agent', 'Example Application/1.0'
));

Http::globalResponseMiddleware(fn ($response) => $response->withHeader(
    'X-Finished-At', now()->toDateTimeString()
));

Opzioni di Guzzle

Puoi specificare opzioni aggiuntive di Guzzle request options per una richiesta in uscita utilizzando il metodo withOptions. Il metodo withOptions accetta un array di coppie chiave/valore:

$response = Http::withOptions([
    'debug' => true,
])->get('http://example.com/users');

Opzioni Globali

Per impostare le opzioni predefinite per ogni richiesta in uscita, puoi utilizzare il metodo globalOptions. Di solito, questo metodo viene chiamato nel metodo boot dell’AppServiceProvider della tua applicazione:

use Illuminate\Support\Facades\Http;

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    Http::globalOptions([
        'allow_redirects' => false,
    ]);
}

Richieste Concorrenti

A volte, potresti voler effettuare più richieste HTTP contemporaneamente. In altre parole, desideri inviare diverse richieste allo stesso tempo invece di emetterle in sequenza. Questo può portare a miglioramenti significativi delle prestazioni quando interagisci con API HTTP lente.

Fortunatamente, puoi realizzare questo utilizzando il metodo pool. Il metodo pool accetta una closure che riceve un’istanza di Illuminate\Http\Client\Pool, permettendoti di aggiungere facilmente richieste al pool per l’invio:

use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;

$responses = Http::pool(fn (Pool $pool) => [
    $pool->get('http://localhost/first'),
    $pool->get('http://localhost/second'),
    $pool->get('http://localhost/third'),
]);

return $responses[0]->ok() &&
       $responses[1]->ok() &&
       $responses[2]->ok();

Come puoi vedere, ogni istanza di risposta può essere accessa in base all’ordine in cui è stata aggiunta al pool. Se desideri, puoi nominare le richieste usando il metodo as, che ti consente di accedere alle risposte corrispondenti per nome:

use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;

$responses = Http::pool(fn (Pool $pool) => [
    $pool->as('first')->get('http://localhost/first'),
    $pool->as('second')->get('http://localhost/second'),
    $pool->as('third')->get('http://localhost/third'),
]);

return $responses['first']->ok();

Personalizzazione delle Richieste Concorrenti

Il metodo pool non può essere concatenato con altri metodi del client HTTP come withHeaders o middleware. Se vuoi applicare header personalizzati o middleware alle richieste nel pool, devi configurare queste opzioni su ogni richiesta nel pool:

use Illuminate\Http\Client\Pool;
use Illuminate\Support\Facades\Http;

$headers = [
    'X-Example' => 'example',
];

$responses = Http::pool(fn (Pool $pool) => [
    $pool->withHeaders($headers)->get('http://laravel.test/test'),
    $pool->withHeaders($headers)->get('http://laravel.test/test'),
    $pool->withHeaders($headers)->get('http://laravel.test/test'),
]);

Macro

Il client HTTP di Laravel ti permette di definire le "macro", che possono essere un meccanismo fluido ed espressivo per configurare percorsi di richiesta e intestazioni comuni quando interagisci con i servizi all’interno della tua applicazione. Per iniziare, puoi definire la macro nel metodo boot della classe App\Providers\AppServiceProvider della tua applicazione:

use Illuminate\Support\Facades\Http;

/**
 * Avvia i servizi dell'applicazione.
 */
public function boot(): void
{
    Http::macro('github', function () {
        return Http::withHeaders([
            'X-Example' => 'example',
        ])->baseUrl('https://github.com');
    });
}

Una volta configurata la tua macro, puoi invocarla da qualsiasi parte della tua applicazione per creare una richiesta in sospeso con la configurazione specificata:

$response = Http::github()->get('/');

Testing

Molti servizi di Laravel offrono funzionalità che ti aiutano a scrivere test in modo semplice ed espressivo, e anche il client HTTP di Laravel non fa eccezione. Il metodo fake del facade Http permette di far restituire al client HTTP risposte simulate o di prova quando vengono effettuate richieste.

Simulazione delle Risposte

Ad esempio, per istruire il client HTTP a restituire risposte vuote con codice di stato 200 per ogni richiesta, puoi chiamare il metodo fake senza argomenti:

use Illuminate\Support\Facades\Http;

Http::fake();

$response = Http::post(/* ... */);

Falsare URL Specifici

In alternativa, puoi passare un array al metodo fake. Le chiavi dell’array dovrebbero rappresentare i pattern degli URL che desideri falsare e le relative risposte. Il carattere * può essere utilizzato come carattere jolly. Qualsiasi richiesta effettuata a URL non falsificati verrà eseguita effettivamente. Puoi utilizzare il metodo response della facade Http per costruire stub / fake responses per questi endpoint:

Http::fake([
    // Stub una risposta JSON per gli endpoint di GitHub...
    'github.com/*' => Http::response(['foo' => 'bar'], 200, $headers),

    // Stub una risposta stringa per gli endpoint di Google...
    'google.com/*' => Http::response('Hello World', 200, $headers),
]);

Se desideri specificare un pattern URL di fallback che simulerà tutti gli URL non corrispondenti, puoi usare un singolo carattere *:

Http::fake([
    // Stub una risposta JSON per gli endpoint di GitHub...
    'github.com/*' => Http::response(['foo' => 'bar'], 200, ['Headers']),

    // Stub una risposta stringa per tutti gli altri endpoint...
    '*' => Http::response('Hello World', 200, ['Headers']),
]);

Per comodità, risposte semplici di tipo stringa, JSON e vuote possono essere generate fornendo una stringa, un array o un intero come risposta:

Http::fake([
    'google.com/*' => 'Hello World',
    'github.com/*' => ['foo' => 'bar'],
    'chatgpt.com/*' => 200,
]);

Simulare Eccezioni di Connessione

A volte potresti dover testare il comportamento della tua applicazione se il client HTTP incontra un Illuminate\Http\Client\ConnectionException durante un tentativo di richiesta. Puoi istruire il client HTTP a generare un’eccezione di connessione usando il metodo failedConnection:

Http::fake([
    'github.com/*' => Http::failedConnection(),
]);

Simulare Sequenze di Risposta

A volte potrebbe essere necessario specificare che un singolo URL restituisca una serie di risposte simulate in un ordine specifico. Puoi ottenere questo utilizzando il metodo Http::sequence per costruire le risposte:

Http::fake([
    // Simula una serie di risposte per gli endpoint di GitHub...
    'github.com/*' => Http::sequence()
                            ->push('Hello World', 200)
                            ->push(['foo' => 'bar'], 200)
                            ->pushStatus(404),
]);

Quando tutte le risposte in una sequenza di risposta sono state consumate, eventuali ulteriori richieste causeranno un’eccezione nella sequenza di risposta. Se desideri specificare una risposta predefinita che dovrebbe essere restituita quando una sequenza è vuota, puoi usare il metodo whenEmpty:

Http::fake([
    // Simula una serie di risposte per gli endpoint di GitHub...
    'github.com/*' => Http::sequence()
                            ->push('Hello World', 200)
                            ->push(['foo' => 'bar'], 200)
                            ->whenEmpty(Http::response()),
]);

Se desideri simulare una sequenza di risposte ma non hai bisogno di specificare un pattern di URL specifico da simulare, puoi usare il metodo Http::fakeSequence:

Http::fakeSequence()
        ->push('Hello World', 200)
        ->whenEmpty(Http::response());

Simulare Logiche Complesse con una Callback

Se hai bisogno di una logica più complessa per determinare quali risposte restituire per determinati endpoint, puoi passare una closure al metodo fake. Questa closure riceverà un’istanza di Illuminate\Http\Client\Request e dovrebbe restituire un’istanza di risposta. All’interno della tua closure, puoi eseguire tutta la logica necessaria per decidere che tipo di risposta restituire:

use Illuminate\Http\Client\Request;

Http::fake(function (Request $request) {
    return Http::response('Hello World', 200);
});

Prevenire le Richieste Errate

Se desideri assicurarti che tutte le richieste inviate tramite il client HTTP siano state simulate durante il tuo test individuale o l’intera suite di test, puoi chiamare il metodo preventStrayRequests. Dopo aver chiamato questo metodo, qualsiasi richiesta che non abbia una risposta falsa corrispondente genererà un’eccezione invece di effettuare la richiesta HTTP reale:

use Illuminate\Support\Facades\Http;

Http::preventStrayRequests();

Http::fake([
    'github.com/*' => Http::response('ok'),
]);

// Viene restituita una risposta "ok"...
Http::get('https://github.com/laravel/framework');

// Viene generata un'eccezione...
Http::get('https://laravel.com');

Ispezionare le Richieste

Quando si simulano risposte, potrebbe essere necessario ispezionare le richieste che il client riceve per assicurarsi che l’applicazione stia inviando i dati o gli header corretti. Puoi fare questo chiamando il metodo Http::assertSent dopo aver chiamato Http::fake.

Il metodo assertSent accetta una closure che riceverà un’istanza di Illuminate\Http\Client\Request e dovrebbe restituire un valore booleano indicando se la richiesta corrisponde alle tue aspettative. Affinché il test passi, almeno una richiesta deve essere stata inviata e deve corrispondere alle aspettative date:

use Illuminate\Http\Client\Request;
use Illuminate\Support\Facades\Http;

Http::fake();

Http::withHeaders([
    'X-First' => 'foo',
])->post('http://example.com/users', [
    'name' => 'Taylor',
    'role' => 'Developer',
]);

Http::assertSent(function (Request $request) {
    return $request->hasHeader('X-First', 'foo') &&
           $request->url() == 'http://example.com/users' &&
           $request['name'] == 'Taylor' &&
           $request['role'] == 'Developer';
});

Se necessario, puoi assicurarti che una specifica richiesta non sia stata inviata usando il metodo assertNotSent:

use Illuminate\Http\Client\Request;
use Illuminate\Support\Facades\Http;

Http::fake();

Http::post('http://example.com/users', [
    'name' => 'Taylor',
    'role' => 'Developer',
]);

Http::assertNotSent(function (Request $request) {
    return $request->url() === 'http://example.com/posts';
});

Puoi usare il metodo assertSentCount per verificare quante richieste sono state "inviate" durante il test:

Http::fake();

Http::assertSentCount(5);

Oppure, puoi usare il metodo assertNothingSent per assicurarti che nessuna richiesta sia stata inviata durante il test:

Http::fake();

Http::assertNothingSent();

Registrazione di Richieste e Risposte

Puoi utilizzare il metodo recorded per raccogliere tutte le richieste e le loro risposte corrispondenti. Il metodo recorded restituisce una collezione di array che contiene istanze di Illuminate\Http\Client\Request e Illuminate\Http\Client\Response:

Http::fake([
    'https://laravel.com' => Http::response(status: 500),
    'https://nova.laravel.com/' => Http::response(),
]);

Http::get('https://laravel.com');
Http::get('https://nova.laravel.com/');

$recorded = Http::recorded();

[$request, $response] = $recorded[0];

Inoltre, il metodo recorded accetta una closure che riceverà un’istanza di Illuminate\Http\Client\Request e Illuminate\Http\Client\Response e può essere utilizzata per filtrare le coppie richiesta/risposta in base alle tue aspettative:

use Illuminate\Http\Client\Request;
use Illuminate\Http\Client\Response;

Http::fake([
    'https://laravel.com' => Http::response(status: 500),
    'https://nova.laravel.com/' => Http::response(),
]);

Http::get('https://laravel.com');
Http::get('https://nova.laravel.com/');

$recorded = Http::recorded(function (Request $request, Response $response) {
    return $request->url() !== 'https://laravel.com' &&
           $response->successful();
});

Eventi

Laravel attiva tre eventi durante il processo di invio delle richieste HTTP. L’evento RequestSending viene attivato prima che una richiesta venga inviata, mentre l’evento ResponseReceived viene attivato dopo aver ricevuto una risposta per una determinata richiesta. L’evento ConnectionFailed viene attivato se non viene ricevuta alcuna risposta per una determinata richiesta.

Gli eventi RequestSending e ConnectionFailed contengono entrambi una proprietà pubblica $request che puoi utilizzare per ispezionare l’istanza Illuminate\Http\Client\Request. Allo stesso modo, l’evento ResponseReceived contiene una proprietà $request e una proprietà $response che possono essere utilizzate per ispezionare l’istanza Illuminate\Http\Client\Response. Puoi creare ascoltatori di eventi per questi eventi all’interno della tua applicazione:

    use Illuminate\Http\Client\Events\RequestSending;

    class LogRequest
    {
        /**
         * Gestisci l'evento dato.
         */
        public function handle(RequestSending $event): void
        {
            // $event->request ...
        }
    }
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