HTTP клієнт

• Вступ
• Виконання запитів
  • Дані запиту
  • Заголовки
  • Аутентифікація
  • Тайм-аут
  • Повторні спроби
  • Обробка Помилок
  • Guzzle Middleware
  • Параметри Guzzle
• Паралельні запити
• Макроси
• Тестування
  • Імітація Відповідей
  • Інспектування Запитів
  • Запобігання випадковим запитам
• Події

Вступ

Laravel надає виразний, мінімальний API навколо Guzzle HTTP клієнта, дозволяючи швидко здійснювати вихідні HTTP-запити для спілкування з іншими веб-застосунками. Обгортка Laravel навколо Guzzle зосереджена на його найпоширеніших випадках використання та чудовому досвіді розробника.

Виконання запитів

Щоб здійснювати запити, ви можете використовувати методи head, get, post, put, patch та delete, які надаються фасадом Http. Спочатку давайте розглянемо, як зробити базовий запит GET до іншої URL-адреси:

use Illuminate\Support\Facades\Http;
 
$response = Http::get('http://example.com');

Метод get повертає екземпляр Illuminate\Http\Client\Response, який надає різноманітні методи, що можуть бути використані для перевірки відповіді:

$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;

Об'єкт Illuminate\Http\Client\Response також реалізує інтерфейс PHP ArrayAccess, що дозволяє отримувати доступ до даних JSON-відповіді безпосередньо у відповіді:

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

На додаток до методів відповіді, перелічених вище, можуть бути використані наступні методи для визначення, чи має відповідь заданий код статусу:

$response->ok() : bool;                  // 200 OK
$response->created() : bool;             // 201 Створено
$response->accepted() : bool;            // 202 Прийнято
$response->noContent() : bool;           // 204 Без вмісту
$response->movedPermanently() : bool;    // 301 Переміщено назавжди
$response->found() : bool;               // 302 Знайдено
$response->badRequest() : bool;          // 400 Неправильний запит
$response->unauthorized() : bool;        // 401 Неавторизовано
$response->paymentRequired() : bool;     // 402 Потрібна оплата
$response->forbidden() : bool;           // 403 Доступ заборонено
$response->notFound() : bool;            // 404 Не знайдено
$response->requestTimeout() : bool;      // 408 Тайм-аут запиту
$response->conflict() : bool;            // 409 Конфлікт
$response->unprocessableEntity() : bool; // 422 Неможливо обробити сутність
$response->tooManyRequests() : bool;     // 429 Забагато запитів
$response->serverError() : bool;         // 500 Внутрішня помилка сервера

URI Шаблони

HTTP-клієнт також дозволяє створювати URL-адреси запитів, використовуючи специфікацію шаблону URI. Щоб визначити параметри URL, які можуть бути розширені вашим шаблоном URI, ви можете використовувати метод withUrlParameters:

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

Виведення Запитів

Якщо ви хочете вивести екземпляр вихідного запиту перед його відправкою та завершити виконання скрипту, ви можете додати метод dd на початок визначення вашого запиту:

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

Дані запиту

Звичайно, при виконанні запитів POST, PUT та PATCH часто надсилаються додаткові дані разом із вашим запитом, тому ці методи приймають масив даних як другий аргумент. За замовчуванням дані будуть надіслані з використанням типу вмісту application/json:

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

GET Запит Параметри Запиту

Коли ви робите запити GET, ви можете або додати рядок запиту безпосередньо до URL, або передати масив пар ключ / значення як другий аргумент методу get:

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

Альтернативно, можна використовувати метод withQueryParameters:

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

Надсилання запитів з кодуванням URL форми

Якщо ви хочете надіслати дані, використовуючи тип вмісту application/x-www-form-urlencoded, ви повинні викликати метод asForm перед виконанням вашого запиту:

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

Надсилання необробленого тіла запиту

Ви можете використовувати метод withBody, якщо хочете надати необроблене тіло запиту під час виконання запиту. Тип вмісту може бути наданий через другий аргумент методу:

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

Багаточастинкові запити

Якщо ви хочете відправляти файли як багаточастинкові запити, ви повинні викликати метод attach перед тим, як зробити ваш запит. Цей метод приймає назву файлу та його вміст. За потреби, ви можете надати третій аргумент, який буде вважатися ім'ям файлу, а четвертий аргумент може бути використаний для надання заголовків, пов'язаних з файлом:

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

Замість передачі сирого вмісту файлу, ви можете передати ресурс потоку:

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

Заголовки

Заголовки можуть бути додані до запитів за допомогою методу withHeaders. Цей метод withHeaders приймає масив пар ключ / значення:

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

Ви можете використовувати метод accept, щоб вказати тип вмісту, який ваш застосунок очікує у відповідь на ваш запит:

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

Для зручності, ви можете використовувати метод acceptJson, щоб швидко вказати, що ваш застосунок очікує тип вмісту application/json у відповідь на ваш запит:

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

Метод withHeaders об'єднує нові заголовки з існуючими заголовками запиту. За потреби, ви можете повністю замінити всі заголовки, використовуючи метод replaceHeaders:

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

Аутентифікація

Ви можете вказати облікові дані базової та дайджест-автентифікації, використовуючи методи withBasicAuth та withDigestAuth відповідно:

// Базова аутентифікація...
$response = Http::withBasicAuth('example@example.com', 'secret')->post(/* ... */);
 
// Аутентифікація за допомогою Digest...
$response = Http::withDigestAuth('example@example.com', 'secret')->post(/* ... */);

Токени Bearer

Якщо ви хочете швидко додати токен носія до заголовка Authorization запиту, ви можете використовувати метод withToken:

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

Тайм-аут

Метод timeout може бути використаний для вказівки максимальної кількості секунд очікування відповіді. За замовчуванням, HTTP-клієнт завершить очікування через 30 секунд:

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

Якщо вказаний тайм-аут перевищено, буде викинуто екземпляр Illuminate\Http\Client\ConnectionException.

Ви можете вказати максимальну кількість секунд для очікування під час спроби підключення до сервера, використовуючи метод connectTimeout. За замовчуванням це 10 секунд:

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

Спроби повтору

Якщо ви хочете, щоб HTTP-клієнт автоматично повторював запит у разі виникнення помилки клієнта або сервера, ви можете використовувати метод retry. Метод retry приймає максимальну кількість спроб виконання запиту та кількість мілісекунд, які Laravel повинен чекати між спробами:

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

Якщо ви хочете вручну обчислити кількість мілісекунд для паузи між спробами, ви можете передати замикання як другий аргумент методу retry:

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

Для зручності, ви також можете надати масив як перший аргумент методу retry. Цей масив буде використовуватися для визначення, скільки мілісекунд слід чекати між наступними спробами:

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

Якщо потрібно, ви можете передати третій аргумент методу retry. Третій аргумент повинен бути callable, який визначає, чи слід дійсно виконувати повторні спроби. Наприклад, ви можете бажати повторити запит лише в тому випадку, якщо початковий запит стикається з ConnectionException:

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

Якщо спроба запиту не вдалася, ви можете захотіти внести зміни до запиту перед тим, як буде зроблено нову спробу. Ви можете досягти цього, змінивши аргумент запиту, наданий у callable, який ви надали методу retry. Наприклад, ви можете захотіти повторити запит з новим токеном авторизації, якщо перша спроба повернула помилку автентифікації:

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(/* ... */);

Якщо всі запити зазнають невдачі, буде викинуто екземпляр Illuminate\Http\Client\RequestException. Якщо ви хочете вимкнути цю поведінку, ви можете надати аргумент throw зі значенням false. Коли вимкнено, остання відповідь, отримана клієнтом, буде повернена після того, як всі спроби будуть виконані:

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

Обробка Помилок

На відміну від поведінки за замовчуванням Guzzle, обгортка HTTP-клієнта Laravel не викидає виключення при клієнтських або серверних помилках (відповіді від серверів рівня 400 та 500). Ви можете визначити, чи була повернена одна з цих помилок, використовуючи методи successful, clientError або serverError:

// Визначте, чи є код статусу >= 200 і < 300...
$response->successful();
 
// Визначте, чи код статусу >= 400...
$response->failed();
 
// Визначте, чи має відповідь статусний код рівня 400...
$response->clientError();
 
// Визначте, чи має відповідь статусний код рівня 500...
$response->serverError();
 
// Негайно виконайте наданий зворотний виклик, якщо сталася помилка клієнта або сервера...
$response->onError(callable $callback);

Генерування винятків

Якщо у вас є екземпляр відповіді і ви хочете викликати екземпляр Illuminate\Http\Client\RequestException, якщо код статусу відповіді вказує на помилку клієнта або сервера, ви можете використовувати методи throw або throwIf:

use Illuminate\Http\Client\Response;
 
$response = Http::post(/* ... */);
 
// Викиньте виняток, якщо сталася помилка клієнта або сервера...
$response->throw();
 
// Киньте виняток, якщо сталася помилка і дана умова є істинною...
$response->throwIf($condition);
 
// Киньте виняток, якщо сталася помилка і передана замикання повертає true...
$response->throwIf(fn (Response $response) => true);
 
// Киньте виняток, якщо сталася помилка і дана умова є хибною...
$response->throwUnless($condition);
 
// Киньте виняток, якщо сталася помилка і передане замикання повертає false...
$response->throwUnless(fn (Response $response) => false);
 
// Кинути виняток, якщо відповідь має певний код статусу...
$response->throwIfStatus(403);
 
// Кинути виняток, якщо відповідь не має певного статус-коду...
$response->throwUnlessStatus(200);
 
return $response['user']['id'];

Екземпляр Illuminate\Http\Client\RequestException має публічну властивість $response, яка дозволить вам перевірити отриману відповідь.

Метод throw повертає екземпляр відповіді, якщо помилка не виникла, дозволяючи вам ланцюжити інші операції до методу throw:

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

Якщо ви хочете виконати додаткову логіку перед тим, як буде викинуто виняток, ви можете передати замикання методу throw. Виняток буде викинуто автоматично після виклику замикання, тому вам не потрібно повторно викидати виняток всередині замикання:

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

За замовчуванням повідомлення RequestException скорочуються до 120 символів при записі в журнал або звітуванні. Щоб налаштувати або вимкнути цю поведінку, ви можете використовувати методи truncateRequestExceptionsAt та dontTruncateRequestExceptions при налаштуванні поведінки обробки винятків вашого застосунку у файлі bootstrap/app.php:

use Illuminate\Foundation\Configuration\Exceptions;
 
->withExceptions(function (Exceptions $exceptions) {
    // Укоротіть повідомлення про виключення запиту до 240 символів...
    $exceptions->truncateRequestExceptionsAt(240);
 
    // Вимкнути усічення повідомлень про виключення запиту...
    $exceptions->dontTruncateRequestExceptions();
})

Альтернативно, ви можете налаштувати поведінку скорочення винятків для кожного запиту, використовуючи метод truncateExceptionsAt:

return Http::truncateExceptionsAt(240)->post(/* ... */);

Guzzle Middleware

Оскільки HTTP-клієнт Laravel працює на базі Guzzle, ви можете скористатися Guzzle Middleware для маніпуляції вихідним запитом або перевірки вхідної відповіді. Щоб маніпулювати вихідним запитом, зареєструйте Guzzle middleware через метод 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');

Аналогічно, ви можете перевірити вхідний HTTP-відповідь, зареєструвавши middleware через метод 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

Іноді ви можете захотіти зареєструвати middleware, яке застосовується до кожного вихідного запиту та вхідної відповіді. Щоб досягти цього, ви можете використовувати методи globalRequestMiddleware та globalResponseMiddleware. Зазвичай ці методи слід викликати в методі boot вашого застосунку в AppServiceProvider:

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()
));

Параметри Guzzle

Ви можете вказати додаткові опції запиту Guzzle для вихідного запиту, використовуючи метод withOptions. Метод withOptions приймає масив пар ключ / значення:

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

Глобальні параметри

Щоб налаштувати параметри за замовчуванням для кожного вихідного запиту, ви можете використовувати метод globalOptions. Зазвичай цей метод слід викликати з методу boot вашого застосунку в AppServiceProvider:

use Illuminate\Support\Facades\Http;
 
/**
 * Ініціалізувати будь-які сервіси застосунку.
 */
public function boot(): void
{
    Http::globalOptions([
        'allow_redirects' => false,
    ]);
}

Паралельні запити

Іноді ви можете захотіти виконати кілька HTTP-запитів одночасно. Іншими словами, ви хочете, щоб кілька запитів були відправлені одночасно, замість того щоб виконувати запити послідовно. Це може призвести до значного покращення продуктивності при взаємодії з повільними HTTP API.

На щастя, ви можете досягти цього, використовуючи метод pool. Метод pool приймає замикання, яке отримує екземпляр Illuminate\Http\Client\Pool, що дозволяє вам легко додавати запити до пулу запитів для відправки:

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();

Як ви можете бачити, кожен екземпляр відповіді може бути доступний на основі порядку, в якому він був доданий до пулу. Якщо бажаєте, ви можете назвати запити, використовуючи метод as, що дозволяє отримати доступ до відповідних відповідей за іменем:

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();

Налаштування одночасних запитів

Метод pool не може бути об'єднаний з іншими методами HTTP-клієнта, такими як методи withHeaders або middleware. Якщо ви хочете застосувати власні заголовки або middleware до запитів у пулі, ви повинні налаштувати ці параметри для кожного запиту в пулі:

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'),
]);

Макроси

Клієнт HTTP Laravel дозволяє визначати "макроси", які можуть служити як плавний, виразний механізм для налаштування загальних шляхів запитів і заголовків при взаємодії з сервісами у вашому застосунку. Щоб почати, ви можете визначити макрос у методі boot класу App\Providers\AppServiceProvider вашого застосунку:

use Illuminate\Support\Facades\Http;
 
/**
 * Запустіть будь-які сервіси застосунку.
 */
public function boot(): void
{
    Http::macro('github', function () {
        return Http::withHeaders([
            'X-Example' => 'example',
        ])->baseUrl('https://github.com');
    });
}

Після того як ваш макрос налаштовано, ви можете викликати його з будь-якого місця у вашому застосунку, щоб створити запит, що очікує, з вказаною конфігурацією:

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

Тестування

Багато сервісів Laravel надають функціональність, яка допомагає вам легко та виразно писати тести, і HTTP-клієнт Laravel не є винятком. Метод fake фасаду Http дозволяє вам вказати HTTP-клієнту повертати підставні / фіктивні відповіді, коли виконуються запити.

Імітація Відповідей

Наприклад, щоб вказати HTTP-клієнту повертати порожні відповіді зі статус-кодом 200 для кожного запиту, ви можете викликати метод fake без аргументів:

use Illuminate\Support\Facades\Http;
 
Http::fake();
 
$response = Http::post(/* ... */);

Підробка конкретних URL-адрес

Альтернативно, ви можете передати масив до методу fake. Ключі масиву повинні представляти шаблони URL, які ви бажаєте підробити, та їх відповідні відповіді. Символ * може бути використаний як символ-джокер. Будь-які запити, зроблені до URL, які не були підроблені, будуть фактично виконані. Ви можете використовувати метод response фасаду Http для створення заглушок / підроблених відповідей для цих кінцевих точок:

Http::fake([
    // Заготовка JSON-відповіді для кінцевих точок GitHub...
    'github.com/*' => Http::response(['foo' => 'bar'], 200, $headers),
 
    // Заглушити рядкову відповідь для Google кінцевих точок...
    'google.com/*' => Http::response('Hello World', 200, $headers),
]);

Якщо ви хочете вказати резервний шаблон URL, який буде обробляти всі невідповідні URL, ви можете використовувати один символ *:

Http::fake([
    // Заготовка JSON-відповіді для кінцевих точок GitHub...
    'github.com/*' => Http::response(['foo' => 'bar'], 200, ['Headers']),
 
    // Заглушити рядкову відповідь для всіх інших кінцевих точок...
    '*' => Http::response('Hello World', 200, ['Headers']),
]);

Для зручності прості рядкові, JSON та порожні відповіді можуть бути згенеровані шляхом надання рядка, масиву або цілого числа як відповіді:

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

Імітація Винятків

Іноді вам може знадобитися протестувати поведінку вашого застосунку, якщо HTTP-клієнт стикається з Illuminate\Http\Client\ConnectionException при спробі виконати запит. Ви можете вказати HTTP-клієнту викидати виключення з'єднання, використовуючи метод failedConnection:

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

Щоб протестувати поведінку вашого застосунку, якщо виникає Illuminate\Http\Client\RequestException, ви можете використовувати метод failedRequest:

Http::fake([
    'github.com/*' => Http::failedRequest(['code' => 'not_found'], 404),
]);

Імітація Послідовностей Відповідей

Іноді вам може знадобитися вказати, що один URL-адреса повинен повертати серію фальшивих відповідей у певному порядку. Ви можете досягти цього, використовуючи метод Http::sequence для створення відповідей:

Http::fake([
    // Заготовте серію відповідей для кінцевих точок GitHub...
    'github.com/*' => Http::sequence()
        ->push('Hello World', 200)
        ->push(['foo' => 'bar'], 200)
        ->pushStatus(404),
]);

Коли всі відповіді в послідовності відповідей були використані, будь-які подальші запити спричинять викидання винятку послідовністю відповідей. Якщо ви хочете вказати відповідь за замовчуванням, яка повинна повертатися, коли послідовність порожня, ви можете використовувати метод whenEmpty:

Http::fake([
    // Заготовте серію відповідей для кінцевих точок GitHub...
    'github.com/*' => Http::sequence()
        ->push('Hello World', 200)
        ->push(['foo' => 'bar'], 200)
        ->whenEmpty(Http::response()),
]);

Якщо ви хочете підробити послідовність відповідей, але не потрібно вказувати конкретний шаблон URL, який слід підробити, ви можете використовувати метод Http::fakeSequence:

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

Фальшивий зворотний виклик

Якщо вам потрібна більш складна логіка для визначення, які відповіді повертати для певних кінцевих точок, ви можете передати замикання в метод fake. Це замикання отримає екземпляр Illuminate\Http\Client\Request і повинно повернути екземпляр відповіді. У межах вашого замикання ви можете виконувати будь-яку необхідну логіку, щоб визначити, який тип відповіді повертати:

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

Інспектування Запитів

Коли ви підробляєте відповіді, іноді може виникнути бажання перевірити запити, які отримує клієнт, щоб переконатися, що ваш застосунок надсилає правильні дані або заголовки. Ви можете досягти цього, викликавши метод Http::assertSent після виклику Http::fake.

Метод assertSent приймає замикання, яке отримає екземпляр Illuminate\Http\Client\Request і повинно повернути булеве значення, що вказує, чи відповідає запит вашим очікуванням. Для того, щоб тест пройшов, принаймні один запит повинен бути виконаний, що відповідає заданим очікуванням:

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';
});

Якщо потрібно, ви можете перевірити, що конкретний запит не був відправлений, використовуючи метод 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';
});

Ви можете використовувати метод assertSentCount, щоб перевірити, скільки запитів було "надіслано" під час тесту:

Http::fake();
 
Http::assertSentCount(5);

Або ви можете використовувати метод assertNothingSent, щоб перевірити, що жодних запитів не було надіслано під час тесту:

Http::fake();
 
Http::assertNothingSent();

Запис Запитів / Відповідей

Ви можете використовувати метод recorded для збору всіх запитів та їх відповідних відповідей. Метод recorded повертає колекцію масивів, що містять екземпляри Illuminate\Http\Client\Request та 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];

Крім того, метод recorded приймає замикання, яке отримає екземпляр Illuminate\Http\Client\Request та Illuminate\Http\Client\Response і може бути використане для фільтрації пар запит/відповідь на основі ваших очікувань:

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();
});

Запобігання випадковим запитам

Якщо ви хочете переконатися, що всі запити, надіслані через HTTP-клієнт, були підроблені протягом вашого окремого тесту або всього тестового набору, ви можете викликати метод preventStrayRequests. Після виклику цього методу будь-які запити, які не мають відповідного підробленого відповіді, викликатимуть виняток замість фактичного виконання HTTP-запиту:

use Illuminate\Support\Facades\Http;
 
Http::preventStrayRequests();
 
Http::fake([
    'github.com/*' => Http::response('ok'),
]);
 
// Повертається відповідь "ok"...
Http::get('https://github.com/laravel/framework');
 
// Викидається виняток...
Http::get('https://laravel.com');

Події

Laravel генерує три події під час процесу відправки HTTP-запитів. Подія RequestSending генерується перед відправкою запиту, тоді як подія ResponseReceived генерується після отримання відповіді на даний запит. Подія ConnectionFailed генерується, якщо відповідь на даний запит не була отримана.

Події RequestSending та ConnectionFailed обидві містять публічну властивість $request, яку ви можете використовувати для перевірки екземпляра Illuminate\Http\Client\Request. Так само, подія ResponseReceived містить властивість $request, а також властивість $response, які можуть бути використані для перевірки екземпляра Illuminate\Http\Client\Response. Ви можете створювати слухачі подій для цих подій у вашому застосунку:

use Illuminate\Http\Client\Events\RequestSending;
 
class LogRequest
{
    /**
     * Обробити подію.
     */
    public function handle(RequestSending $event): void
    {
        // $event->request ...
    }
}