Тестирование HTTP-запросов в Laravel 10.x: Написание и Проверка Тестов

Введение
Отправка запросов
Тестирование JSON API
- Fluent JSON Testing
Тестирование загрузки файлов
Тестирование представлений
- Отрисовка Blade & Components
Доступные утверждения

Введение

Laravel предоставляет очень плавный API для выполнения HTTP-запросов к вашему приложению и анализа ответов. Например, рассмотрим определенный ниже фич-тест:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример теста.
     */
    public function test_the_application_returns_a_successful_response(): void
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

Метод get выполняет запрос GET в приложение, а метод assertStatus утверждает, что возвращенный ответ должен иметь указанный HTTP-код состояния. Помимо этого простого утверждения, Laravel также содержит различные утверждения для проверки заголовков ответа, содержимого, структуры JSON и многого другого.

Отправка запросов

Чтобы выполнить запрос к вашему приложению, вы можете вызывать методы get, post, put, patch или delete внутри вашего теста. Эти методы фактически не выполняют "реальный" HTTP-запрос к вашему приложению. Вместо этого весь сетевой запрос симулируется внутренне.

Вместо возвращения экземпляра Illuminate\Http\Response методы тестирования возвращают экземпляр Illuminate\Testing\TestResponse, который предоставляет разнообразие полезных утверждений, позволяя вам проверять ответы вашего приложения:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример теста.
     */
    public function test_a_basic_request(): void
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

В общем случае каждый из ваших тестов должен делать только один запрос к вашему приложению. Неожиданное поведение может возникнуть, если в пределах одного метода теста выполняются несколько запросов.

Примечание Для удобства CSRF-промежуточное ПО автоматически отключается при выполнении тестов.

Настройка заголовков запроса

В целом каждый из ваших тестов должен выполнять только один запрос к вашему приложению. Неожиданное поведение может возникнуть, если в пределах одного метода теста выполняются несколько запросов.

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример функционального теста.
     */
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);
 
        $response->assertStatus(201);
    }
}

Cookies

Вы можете использовать методы withCookie или withCookies для установки значений cookie перед отправкой запроса. Метод withCookie принимает имя и значение cookie в качестве двух аргументов, в то время как метод withCookies принимает массив пар имя / значение:

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

Сессия / Аутентификация

Laravel предоставляет несколько вспомогательных функций для взаимодействия с сессией во время HTTP-тестирования. В первую очередь, вы можете установить данные сессии для заданного массива, используя метод withSession. Это полезно для загрузки сессии данными перед отправкой запроса к вашему приложению:

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

Сессия Laravel обычно используется для поддержания состояния текущего аутентифицированного пользователя. Таким образом, метод-помощник actingAs предоставляет простой способ аутентификации заданного пользователя как текущего. Например, мы можем использовать фабрику моделей для создания и аутентификации пользователя:

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

Также вы можете указать, какая охрана должна быть использована для аутентификации заданного пользователя, передав имя охраны вторым аргументом методу actingAs. Охрана, предоставленная методу actingAs, также станет основной охраной на время теста:

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

Отладка ответов

После отправки тестового запроса к вашему приложению методы dump, dumpHeaders и dumpSession могут быть использованы для проверки и отладки содержимого ответа:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример теста.
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');
 
        $response->dumpHeaders();
 
        $response->dumpSession();
 
        $response->dump();
    }
}

В качестве альтернативы вы можете использовать методы dd, ddHeaders и ddSession для вывода информации о ответе и затем остановки выполнения:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример теста.
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');
 
        $response->ddHeaders();
 
        $response->ddSession();
 
        $response->dd();
    }
}

Обработка исключений

Иногда вам может потребоваться проверить, что ваше приложение вызывает определенное исключение. Чтобы обеспечить, чтобы исключение не попало в обработчик исключений Laravel и не было возвращено в виде HTTP-ответа, вы можете вызвать метод withoutExceptionHandling перед выполнением вашего запроса:

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

Кроме того, если вы хотите убедиться, что ваше приложение не использует функции, которые были устаревши в PHP или библиотеках, которые использует ваше приложение, вы можете вызвать метод withoutDeprecationHandling перед выполнением запроса. Когда обработка устаревших функций отключена, предупреждения об устаревании будут преобразованы в исключения, что вызовет сбой вашего теста:

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

Метод assertThrows может быть использован для проверки того, что код внутри заданного замыкания генерирует исключение указанного типа:

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

Тестирование JSON API

Кроме того, Laravel предоставляет несколько вспомогательных методов для тестирования JSON API и их ответов. Например, методы json, getJson, postJson, putJson, patchJson, deleteJson и optionsJson могут быть использованы для отправки JSON-запросов с различными HTTP-глаголами. Вы также легко можете передавать данные и заголовки в эти методы. Давайте напишем тест для выполнения POST-запроса к /api/user и проверки, что ожидаемые JSON-данные были возвращены:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример функционального теста.
     */
    public function test_making_an_api_request(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);
 
        $response
            ->assertStatus(201)
            ->assertJson([
                'created' => true,
            ]);
    }
}

Кроме того, данные JSON-ответа могут быть получены как массивовые переменные в ответе, что удобно для проверки индивидуальных значений, возвращенных внутри JSON-ответа:

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

Примечание Метод assertJson преобразует ответ в массив и использует PHPUnit::assertArraySubset для проверки того, что данный массив существует в JSON-ответе, возвращенном приложением. Таким образом, если в JSON-ответе есть другие свойства, этот тест все равно пройдет, если данный фрагмент присутствует.

Утверждение точного соответствия JSON

Как было упомянуто ранее, метод assertJson может быть использован для проверки того, что фрагмент JSON существует внутри JSON-ответа. Если вы хотите убедиться, что данный массив точно соответствует JSON, возвращенному вашим приложением, следует использовать метод assertExactJson:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример функционального теста.
     */
    public function test_asserting_an_exact_json_match(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);
 
        $response
            ->assertStatus(201)
            ->assertExactJson([
                'created' => true,
            ]);
    }
}

Утверждение по JSON-путям

Если вы хотите убедиться, что JSON-ответ содержит данные по указанному пути, следует использовать метод assertJsonPath:

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * Простой пример функционального теста.
     */
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);
 
        $response
            ->assertStatus(201)
            ->assertJsonPath('team.owner.name', 'Darian');
    }
}

Метод assertJsonPath также принимает замыкание, которое может быть использовано для динамического определения, должно ли пройти это утверждение:

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

Fluent JSON Testing

Laravel также предлагает красивый способ плавно тестировать JSON-ответы вашего приложения. Для начала передайте замыкание методу assertJson. Это замыкание будет вызвано с экземпляром Illuminate\Testing\Fluent\AssertableJson, который можно использовать для утверждений относительно JSON, возвращенного вашим приложением. Метод where может быть использован для утверждений относительно конкретного атрибута JSON, а метод missing - для проверки отсутствия конкретного атрибута в JSON:

use Illuminate\Testing\Fluent\AssertableJson;
 
/**
 * Простой пример функционального теста.
 */
public function test_fluent_json(): void
{
    $response = $this->getJson('/users/1');
 
    $response
        ->assertJson(fn (AssertableJson $json) =>
            $json->where('id', 1)
                 ->where('name', 'Victoria Faith')
                 ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                 ->whereNot('status', 'pending')
                 ->missing('password')
                 ->etc()
        );
}

Понимание метода `etc`

В приведенном выше примере вы, возможно, заметили, что мы вызвали метод etc в конце нашей цепочки утверждений. Этот метод информирует Laravel о том, что в JSON-объекте могут присутствовать другие атрибуты. Если метод etc не используется, тест завершится неудачей, если в JSON-объекте будут присутствовать другие атрибуты, по которым вы не предъявляли утверждений.

Целью этого поведения является защита вас от непреднамеренного раскрытия чувствительной информации в ваших JSON-ответах, заставляя вас либо явно предъявлять утверждение по атрибуту, либо явно разрешать дополнительные атрибуты с помощью метода etc.

Тем не менее, стоит помнить, что отсутствие метода etc в цепочке утверждений не гарантирует, что к массивам, вложенным в ваш JSON-объект, не добавляются дополнительные атрибуты. Метод etc обеспечивает только отсутствие дополнительных атрибутов на уровне вложенности, в котором вызывается метод etc.

Утверждение присутствия / отсутствия атрибутов

Чтобы утверждать, присутствует ли или отсутствует атрибут, вы можете использовать методы has и missing:

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

Кроме того, методы hasAll и missingAll позволяют утверждать присутствие или отсутствие нескольких атрибутов одновременно:

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

Метод hasAny позволяет определить, присутствует ли хотя бы один из заданного списка атрибутов:

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

Утверждение по коллекциям JSON

Часто ваш маршрут вернет JSON-ответ, содержащий несколько элементов, таких как несколько пользователей:

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

В этих ситуациях мы можем использовать метод has объекта JSON для утверждений относительно пользователей, включенных в ответ. Например, давайте утверждать, что JSON-ответ содержит три пользователя. Затем мы сделаем несколько утверждений о первом пользователе в коллекции, используя метод first. Метод first принимает замыкание, которое получает другую строку JSON, которую мы можем использовать для утверждений о первом объекте в коллекции 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('[email protected]'))
                     ->missing('password')
                     ->etc()
             )
    );

Область действия утверждений коллекции JSON

Иногда маршруты вашего приложения будут возвращать JSON-коллекции, которым назначены именованные ключи:

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

При тестировании этих маршрутов вы можете использовать метод has для утверждения по количеству элементов в коллекции. Кроме того, вы можете использовать метод has для создания цепочки утверждений:

$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('[email protected]'))
                     ->missing('password')
                     ->etc()
             )
    );

Вместо того чтобы делать два отдельных вызова метода has для утверждения коллекции users, можно сделать единичный вызов, предоставив замыкание в качестве его третьего параметра. При этом замыкание будет автоматически вызвано и ограничено первым элементом в коллекции:

$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('[email protected]'))
                     ->missing('password')
                     ->etc()
             )
    );

Утверждение типов JSON

Вы можете хотеть утверждать, что свойства в JSON-ответе имеют определенный тип. Класс Illuminate\Testing\Fluent\AssertableJson предоставляет методы whereType и whereAllType для этого:

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

Вы можете указать несколько типов, используя символ | или передав массив типов в качестве второго параметра методу whereType. Утверждение будет успешным, если значение ответа будет любым из перечисленных типов:

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

Методы whereType и whereAllType распознают следующие типы: string, integer, double, boolean, array и null.

Тестирование загрузки файлов

Класс Illuminate\Http\UploadedFile предоставляет метод fake, который можно использовать для создания фиктивных файлов или изображений для тестирования. Это, в сочетании с методом fake фасада Storage, существенно упрощает тестирование загрузки файлов. Например, вы можете объединить эти две функции, чтобы легко протестировать форму загрузки аватара:

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

Если вы хотите утверждать, что данный файл не существует, вы можете использовать метод assertMissing, предоставляемый фасадом Storage:

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

Настройка фиктивного файла

При создании файлов с использованием метода fake, предоставленного классом UploadedFile, вы можете указать ширину, высоту и размер изображения (в килобайтах), чтобы лучше тестировать правила валидации вашего приложения:

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

Помимо создания изображений, вы можете создавать файлы любого другого типа с использованием метода create:

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

При необходимости вы можете передать аргумент $mimeType методу, чтобы явно определить MIME-тип, который должен быть возвращен файлом:

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

Тестирование представлений

Laravel также позволяет вам рендерить представление, не выполняя симулированный HTTP-запрос к приложению. Для этого вы можете вызвать метод view внутри вашего теста. Метод view принимает имя представления и необязательный массив данных. Метод возвращает экземпляр Illuminate\Testing\TestView, который предоставляет несколько методов для удобной проверки содержимого представления:

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

Класс TestView предоставляет следующие методы утверждения: assertSee, assertSeeInOrder, assertSeeText, assertSeeTextInOrder, assertDontSee и assertDontSeeText.

При необходимости вы можете получить сырое, отрендеренное содержимое представления, приведя экземпляр TestView к строке:

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

Обмен ошибками

Некоторые представления могут зависеть от ошибок, переданных в глобальный мешок ошибок Laravel. Чтобы добавить в мешок ошибок сообщения об ошибках, вы можете использовать метод withViewErrors:

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

Отрисовка Blade & Components

При необходимости вы можете использовать метод blade для оценки и рендеринга сырой строки Blade. Как и метод view, метод blade возвращает экземпляр Illuminate\Testing\TestView:

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

Вы можете использовать метод component для оценки и рендеринга компонента Blade. Метод component возвращает экземпляр Illuminate\Testing\TestComponent:

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

Доступные утверждения

Утверждения ответа

Класс Illuminate\Testing\TestResponse Laravel предоставляет разнообразие методов утверждения, которые вы можете использовать при тестировании вашего приложения. Эти утверждения могут быть доступны на ответе, который возвращает метод тестирования, такой как json, get, post, put и delete:

assertAccepted assertBadRequest assertConflict assertCookie assertCookieExpired assertCookieNotExpired assertCookieMissing assertCreated assertDontSee assertDontSeeText assertDownload assertExactJson assertForbidden assertFound assertGone assertHeader assertHeaderMissing assertInternalServerError assertJson assertJsonCount assertJsonFragment assertJsonIsArray assertJsonIsObject assertJsonMissing assertJsonMissingExact assertJsonMissingValidationErrors assertJsonPath assertJsonMissingPath assertJsonStructure assertJsonValidationErrors assertJsonValidationErrorFor assertLocation assertMethodNotAllowed assertMovedPermanently assertContent assertNoContent assertStreamedContent assertNotFound assertOk assertPaymentRequired assertPlainCookie assertRedirect assertRedirectContains assertRedirectToRoute assertRedirectToSignedRoute assertRequestTimeout assertSee assertSeeInOrder assertSeeText assertSeeTextInOrder assertServerError assertServiceUnavailable assertSessionHas assertSessionHasInput assertSessionHasAll assertSessionHasErrors assertSessionHasErrorsIn assertSessionHasNoErrors assertSessionDoesntHaveErrors assertSessionMissing assertStatus assertSuccessful assertTooManyRequests assertUnauthorized assertUnprocessable assertUnsupportedMediaType assertValid assertInvalid assertViewHas assertViewHasAll assertViewIs assertViewMissing

assertBadRequest

Утверждать, что у ответа код состояния HTTP "Плохой запрос" (400):

$response->assertBadRequest();

assertAccepted

Утверждать, что у ответа код состояния HTTP "Принято" (202):

$response->assertAccepted();

assertConflict

Утверждать, что у ответа код состояния HTTP "Конфликт" (409):

$response->assertConflict();

assertCookie

Утверждать, что ответ содержит указанную куку:

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

assertCookieExpired

Утверждать, что ответ содержит указанную куку и она истекла:

$response->assertCookieExpired($cookieName);

assertCookieNotExpired

Утверждать, что ответ содержит указанную куку и она не истекла:

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

Утверждать, что ответ не содержит указанную куку:

$response->assertCookieMissing($cookieName);

assertCreated

Утверждать, что у ответа код состояния HTTP 201:

$response->assertCreated();

assertDontSee

Утверждать, что данная строка не содержится в ответе, возвращенном приложением. Это утверждение автоматически экранирует данную строку, если вы не передадите второй аргумент false:

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

assertDontSeeText

Утверждать, что данная строка не содержится в тексте ответа. Это утверждение автоматически экранирует данную строку, если вы не передадите второй аргумент false. Этот метод передает содержимое ответа функции strip_tags PHP перед совершением утверждения:

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

assertDownload

Утверждать, что ответ - это "загрузка". Обычно это означает, что вызванный маршрут, возвращающий ответ, вернул Response::download, BinaryFileResponse или Storage::download:

$response->assertDownload();

При необходимости вы можете утверждать, что загружаемому файлу было присвоено указанное имя файла:

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

assertExactJson

Утверждать, что ответ содержит точное соответствие указанным данным JSON:

$response->assertExactJson(array $data);

assertForbidden

Утверждать, что у ответа код состояния HTTP "Запрещено" (403):

$response->assertForbidden();

assertFound

Утверждать, что у ответа код состояния HTTP "Найдено" (302):

$response->assertFound();

assertGone

Утверждать, что у ответа код состояния HTTP "Ушел" (410):

$response->assertGone();

assertHeader

Утверждать, что указанный заголовок и значение присутствуют в ответе:

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

assertHeaderMissing

Утверждать, что указанный заголовок отсутствует в ответе:

$response->assertHeaderMissing($headerName);

assertInternalServerError

Утверждать, что у ответа код состояния HTTP "Внутренняя ошибка сервера" (500):

$response->assertInternalServerError();

assertJson

Утверждать, что ответ содержит указанные данные JSON:

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

Метод assertJson преобразует ответ в массив и использует PHPUnit::assertArraySubset, чтобы проверить, что данный массив существует в JSON-ответе, возвращенном приложением. Таким образом, если в JSON-ответе есть другие свойства, этот тест все равно будет успешным, пока данный фрагмент присутствует.

assertJsonCount

Утверждать, что в JSON-ответе есть массив с ожидаемым количеством элементов по указанному ключу:

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

assertJsonFragment

Утверждать, что ответ содержит указанные данные JSON где-то в ответе:

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

assertJsonIsArray

Утверждать, что JSON-ответ - это массив:

$response->assertJsonIsArray();

assertJsonIsObject

Утверждать, что JSON-ответ - это объект:

$response->assertJsonIsObject();

assertJsonMissing

Утверждать, что ответ не содержит указанные данные JSON:

$response->assertJsonMissing(array $data);

assertJsonMissingExact

Утверждать, что ответ не содержит точные данные JSON:

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

Утверждать, что у ответа нет ошибок валидации JSON для указанных ключей:

$response->assertJsonMissingValidationErrors($keys);

Примечание Более общий метод assertValid можно использовать для проверки отсутствия ошибок валидации в ответе в форме JSON и отсутствия ошибок в сессии.

assertJsonPath

Утверждать, что ответ содержит указанные данные по указанному пути:

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

Например, если ваше приложение возвращает следующий JSON-ответ:

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

Вы можете утверждать, что свойство name объекта user соответствует заданному значению таким образом:

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

assertJsonMissingPath

Утверждать, что ответ не содержит указанного пути:

$response->assertJsonMissingPath($path);

Например, если ваше приложение возвращает следующий JSON-ответ:

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

Вы можете утверждать, что в нем нет свойства email объекта user:

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

assertJsonStructure

Утверждать, что ответ имеет заданную структуру JSON:

$response->assertJsonStructure(array $structure);

Например, если JSON-ответ, возвращенный вашим приложением, содержит следующие данные:

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

Вы можете утверждать, что структура JSON соответствует вашим ожиданиям так:

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

Иногда JSON-ответы, возвращенные вашим приложением, могут содержать массивы объектов:

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

В этой ситуации вы можете использовать символ *, чтобы утверждать структуру всех объектов в массиве:

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

assertJsonValidationErrors

Утверждать, что у ответа есть указанные ошибки валидации JSON для указанных ключей. Этот метод следует использовать при утверждении ответов, в которых ошибки валидации возвращаются в виде структуры JSON, а не сохраняются в сессии:

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

Примечание Более общий метод assertInvalid можно использовать для проверки наличия ошибок валидации в ответе в форме JSON или наличия ошибок в сессии.

assertJsonValidationErrorFor

Утверждает, что ответ содержит ошибки валидации JSON для указанного ключа:

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

assertMethodNotAllowed

Утверждает, что ответ имеет код состояния HTTP "Method Not Allowed" (405):

$response->assertMethodNotAllowed();

assertMovedPermanently

Утверждает, что ответ имеет код состояния HTTP "Moved Permanently" (301):

$response->assertMovedPermanently();

assertLocation

Утверждает, что ответ содержит указанное значение URI в заголовке Location:

$response->assertLocation($uri);

assertContent

Утверждает, что данная строка совпадает с содержимым ответа:

$response->assertContent($value);

assertNoContent

Утверждает, что ответ имеет указанный код состояния HTTP и не содержит контента:

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

assertStreamedContent

Утверждает, что указанная строка совпадает с контентом ответа в потоковом режиме:

$response->assertStreamedContent($value);

assertNotFound

Утверждает, что ответ имеет код состояния HTTP "Not Found" (404):

$response->assertNotFound();

assertOk

Утверждает, что ответ имеет код состояния HTTP "OK" (200):

$response->assertOk();

assertPaymentRequired

Утверждает, что ответ имеет код состояния HTTP "Payment Required" (402):

$response->assertPaymentRequired();

assertPlainCookie

Утверждает, что ответ содержит указанную нешифрованную cookie:

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

assertRedirect

Утверждает, что ответ является перенаправлением на указанное URI:

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

assertRedirectContains

Утверждает, является ли ответ перенаправлением на URI, содержащий указанную строку:

$response->assertRedirectContains($string);

assertRedirectToRoute

Утверждает, что ответ является перенаправлением на указанный именованный маршрут:

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

assertRedirectToSignedRoute

Утверждает, что ответ является перенаправлением на указанный подписанный маршрут:

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

assertRequestTimeout

Утверждает, что ответ имеет код состояния HTTP "Request Timeout" (408):

$response->assertRequestTimeout();

assertSee

Утверждает, что указанная строка содержится в ответе. Это утверждение автоматически экранирует указанную строку, если не передан второй аргумент со значением false:

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

assertSeeInOrder

Утверждает, что указанные строки присутствуют в ответе в заданном порядке. Это утверждение автоматически экранирует указанные строки, если не передан второй аргумент со значением false:

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

assertSeeText

Утверждает, что указанная строка присутствует в тексте ответа. Это утверждение автоматически экранирует указанную строку, если не передан второй аргумент со значением false. Содержимое ответа будет передано функции strip_tags PHP перед выполнением утверждения:

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

assertSeeTextInOrder

Утверждает, что указанные строки присутствуют в тексте ответа в заданном порядке. Это утверждение автоматически экранирует указанные строки, если не передан второй аргумент со значением false. Содержимое ответа будет передано функции strip_tags PHP перед выполнением утверждения:

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

assertServerError

Утверждает, что ответ имеет код состояния HTTP "Server Error" (>= 500 , < 600):

$response->assertServerError();

assertServiceUnavailable

Утверждает, что ответ имеет код состояния HTTP "Service Unavailable" (503):

$response->assertServiceUnavailable();

assertSessionHas

Утверждает, что сессия содержит указанные данные:

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

При необходимости вторым аргументом для метода assertSessionHas может быть передано замыкание. Утверждение пройдет, если замыкание вернет true:

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

assertSessionHasInput

Утверждает, что в сессии присутствует указанное значение в массиве перенаправленных входных данных:

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

При необходимости вторым аргументом для метода assertSessionHasInput можно передать замыкание. Утверждение пройдет, если замыкание вернет true:

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

assertSessionHasAll

Утверждает, что сессия содержит заданный массив пар ключ / значение:

$response->assertSessionHasAll(array $data);

Например, если сессия вашего приложения содержит ключи name и status, вы можете утверждать, что они существуют и имеют указанные значения, таким образом:

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

assertSessionHasErrors

Утверждайте, что в сессии есть ошибка для заданных $keys. Если $keys - ассоциативный массив, утверждайте, что в сессии есть конкретное сообщение об ошибке (значение) для каждого поля (ключа). Этот метод следует использовать при тестировании маршрутов, которые сохраняют сообщения об ошибках в сессии вместо возвращения их в виде JSON-структуры:

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

Например, чтобы утверждать, что поля name и email содержат сообщения об ошибках валидации, которые были сохранены в сессии, вы можете вызвать метод assertSessionHasErrors следующим образом:

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

Или вы можете утверждать, что у определенного поля есть конкретное сообщение об ошибке валидации:

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

Примечание Более общий метод assertInvalid можно использовать для проверки наличия ошибок валидации в ответе в форме JSON или наличия ошибок в сессии.

assertSessionHasErrorsIn

Утверждайте, что в сессии есть ошибка для заданных $keys внутри конкретного error bag. Если $keys - ассоциативный массив, утверждайте, что в сессии есть конкретное сообщение об ошибке (значение) для каждого поля (ключа) внутри error bag:

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

assertSessionHasNoErrors

Утверждайте, что в сессии нет ошибок валидации:

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

Утверждайте, что в сессии нет ошибок валидации для заданных ключей:

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

Примечание Более общий метод assertValid можно использовать для проверки отсутствия ошибок валидации в ответе в форме JSON и отсутствия ошибок в сессии.

assertSessionMissing

Утверждайте, что в сессии нет заданного ключа:

$response->assertSessionMissing($key);

assertStatus

Утверждайте, что ответ имеет указанный HTTP-код состояния:

$response->assertStatus($code);

assertSuccessful

Утверждайте, что ответ имеет успешный HTTP-код состояния (>= 200 и < 300):

$response->assertSuccessful();

assertTooManyRequests

Утверждайте, что ответ имеет код состояния HTTP "слишком много запросов" (429):

$response->assertTooManyRequests();

assertUnauthorized

Утверждайте, что ответ имеет код состояния HTTP "не авторизован" (401):

$response->assertUnauthorized();

assertUnprocessable

Утверждайте, что ответ имеет код состояния HTTP "непроходимая сущность" (422):

$response->assertUnprocessable();

assertUnsupportedMediaType

Утверждайте, что ответ имеет код состояния HTTP "неподдерживаемый тип медиа" (415):

$response->assertUnsupportedMediaType();

assertValid

Утверждайте, что в ответе нет ошибок валидации для указанных ключей. Этот метод можно использовать для утверждения ответов, где ошибки валидации возвращаются в виде JSON-структуры или где ошибки валидации были сохранены в сессии:

// Утверждение, что ошибок валидации нет... $response->assertValid();

// Утверждение, что у указанных ключей нет ошибок валидации... $response->assertValid(['name', 'email']);

assertInvalid

Утверждайте, что в ответе есть ошибки валидации для указанных ключей. Этот метод можно использовать для утверждения ответов, где ошибки валидации возвращаются в виде JSON-структуры или где ошибки валидации были сохранены в сессии:

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

Также вы можете утверждать, что у определенного ключа есть конкретное сообщение об ошибке валидации. При этом вы можете предоставить всё сообщение или только его часть:

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

assertViewHas

Утверждайте, что вид ответа содержит указанные данные:

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

Передача замыкания вторым аргументом методу assertViewHas позволит вам проверить и делать утверждения относительно конкретной части данных представления:

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

Кроме того, данные представления можно получить как массивовые переменные в ответе, что позволяет вам удобно их проверять:

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

assertViewHasAll

Утверждайте, что вид ответа содержит указанный список данных:

$response->assertViewHasAll(array $data);

Этот метод можно использовать для утверждения того, что вид просто содержит данные, соответствующие данным ключам:

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

Или вы можете утверждать, что данные представления присутствуют и имеют конкретные значения:

$response->assertViewHasAll([
    'name' => 'Taylor Otwell',
    'email' => '[email protected],',
]);

assertViewIs

Утверждайте, что указанный вид был возвращен маршрутом:

$response->assertViewIs($value);

assertViewMissing

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

$response->assertViewMissing($key);

Утверждения аутентификации

Кроме того, Laravel предоставляет различные утверждения, связанные с аутентификацией, которые вы можете использовать в тестах вашего приложения. Обратите внимание, что эти методы вызываются в самом классе теста, а не в экземпляре Illuminate\Testing\TestResponse, возвращаемом методами get и post.

assertAuthenticated

Утверждайте, что пользователь аутентифицирован:

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

assertGuest

Утверждайте, что пользователь не аутентифицирован:

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

assertAuthenticatedAs

Утверждайте, что определенный пользователь аутентифицирован:

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

Утверждения валидации

Laravel предоставляет два основных утверждения, связанных с валидацией, которые вы можете использовать, чтобы удостовериться, что данные, предоставленные в вашем запросе, были либо допустимы, либо недопустимы.