http-tests.md

Laravel 8 · Тестирование · Тесты HTTP

• Введение
• Выполнение запросов
  • Настройка заголовков запросов
  • Cookies
  • Сессия / Аутентификация
  • Отладка ответов
• Тестирование JSON API
  • Последовательное тестирование JSON
• Тестирование загрузки файлов
• Тестирование шаблонной системы
  • Отрисовка Blade и компоненты
• Доступные утверждения
  • Утверждения ответов
  • Утверждения аутентификации

Введение

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

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_a_basic_request()
    {
        $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 Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_a_basic_request()
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

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

{tip} Для удобства посредник CSRF автоматически отключается при запуске тестов.

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

Вы можете использовать метод withHeaders для настройки заголовков запроса перед его отправкой в приложение. Этот метод позволяет вам добавлять в запрос любые пользовательские заголовки:

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_interacting_with_headers()
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

Cookies

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_interacting_with_cookies()
    {
        $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()
    {
        $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()
    {
        $user = User::factory()->create();

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

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

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

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

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

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_basic_test()
    {
        $response = $this->get('/');

        $response->dumpHeaders();

        $response->dumpSession();

        $response->dump();
    }
}

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

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_making_an_api_request()
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);

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

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

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

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

Утверждение точных совпадений JSON

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_asserting_an_exact_json_match()
    {
        $response = $this->json('POST', '/user', ['name' => 'Sally']);

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

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

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * Отвлеченный пример функционального теста.
     *
     * @return void
     */
    public function test_asserting_a_json_paths_value()
    {
        $response = $this->json('POST', '/user', ['name' => 'Sally']);

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

Последовательное тестирование JSON

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

use Illuminate\Testing\Fluent\AssertableJson;

/**
 * Отвлеченный пример функционального теста.
 *
 * @return void
 */
public function test_fluent_json()
{
    $response = $this->json('GET', '/users/1');

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

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

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

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

Утверждения относительно коллекций JSON

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

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

В этих ситуациях можно использовать метод has последовательного тестирования JSON, чтобы сделать утверждения относительно пользователей, содержащихся в ответе. Например, предположим, что ответ JSON содержит трех пользователей. Затем мы сделаем некоторые утверждения относительно первого пользователя в коллекции, используя метод first. Метод first принимает замыкание, получающее другой экземпляр AssertableJson, который можно использовать для создания утверждений относительно первого объекта коллекции JSON:

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

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

$response
    ->assertJson(fn (AssertableJson $json) =>
        $json->has('meta')
             ->has('users', 3, fn ($json) =>
                $json->where('id', 1)
                     ->where('name', 'Victoria Faith')
                     ->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\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_avatars_can_be_uploaded()
    {
        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()
    {
        $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 и компоненты

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

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

$view->assertSee('Taylor');

Вы можете использовать метод component для анализа и отрисовки компонента Blade. Как и метод view, метод component возвращает экземпляр Illuminate\Testing\TestView:

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

$view->assertSee('Taylor');

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

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

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

• assertCookie
• assertCookieExpired
• assertCookieNotExpired
• assertCookieMissing
• assertCreated
• assertDontSee
• assertDontSeeText
• assertDownload
• assertExactJson
• assertForbidden
• assertHeader
• assertHeaderMissing
• assertJson
• assertJsonCount
• assertJsonFragment
• assertJsonMissing
• assertJsonMissingExact
• assertJsonMissingValidationErrors
• assertJsonPath
• assertJsonStructure
• assertJsonValidationErrors
• assertLocation
• assertNoContent
• assertNotFound
• assertOk
• assertPlainCookie
• assertRedirect
• assertRedirectToSignedRoute
• assertSee
• assertSeeInOrder
• assertSeeText
• assertSeeTextInOrder
• assertSessionHas
• assertSessionHasInput
• assertSessionHasAll
• assertSessionHasErrors
• assertSessionHasErrorsIn
• assertSessionHasNoErrors
• assertSessionDoesntHaveErrors
• assertSessionMissing
• assertStatus
• assertSuccessful
• assertUnauthorized
• assertValid
• assertInvalid
• assertViewHas
• assertViewHasAll
• assertViewIs
• assertViewMissing

assertCookie

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

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

assertCookieExpired

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

$response->assertCookieExpired($cookieName);

assertCookieNotExpired

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

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

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

$response->assertCookieMissing($cookieName);

assertCreated

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

$response->assertCreated();

assertDontSee

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

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

assertDontSeeText

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

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

assertDownload

Утверждение о том, что ответ является «загрузкой». Обычно это означает, что был вызван маршрут, который вернул ответ Response::download, BinaryFileResponse или Storage::download:

$response->assertDownload();

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

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

assertExactJson

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

$response->assertExactJson(array $data);

assertForbidden

Утверждение о том, что ответ имеет код 403 состояния HTTP – forbidden:

$response->assertForbidden();

assertHeader

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

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

assertHeaderMissing

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

$response->assertHeaderMissing($headerName);

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

assertJsonMissing

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

$response->assertJsonMissing(array $data);

assertJsonMissingExact

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

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

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

$response->assertJsonMissingValidationErrors($keys);

assertJsonPath

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

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

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

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

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

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

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

assertLocation

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

$response->assertLocation($uri);

assertNoContent

Утверждение о том, что ответ имеет код 204 состояния HTTP – no content:

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

assertNotFound

Утверждение о том, что ответ имеет код 404 состояния HTTP – not found:

$response->assertNotFound();

assertOk

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

$response->assertOk();

assertPlainCookie

Утверждение о том, что ответ содержит переданный незашифрованный cookie:

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

assertRedirect

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

$response->assertRedirect($uri);

assertRedirectToSignedRoute

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

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

assertSee

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

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

assertSeeInOrder

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

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

assertSeeText

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

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

assertSeeTextInOrder

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

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

assertSessionHas

Утверждение о том, что сессия содержит переданный фрагмент данных:

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

assertSessionHasInput

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

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

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

assertSessionHasErrorsIn

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

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

assertSessionHasNoErrors

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

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

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

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

assertSessionMissing

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

$response->assertSessionMissing($key);

assertStatus

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

$response->assertStatus($code);

assertSuccessful

Утверждение о том, что ответ имеет код >= 200 и < 300 состояния HTTP – successful:

$response->assertSuccessful();

assertUnauthorized

Утверждение о том, что ответ имеет код 401 состояния HTTP – unauthorized:

$response->assertUnauthorized();

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