Поддержите проект сделав пожертвование.
Документация
●
Поддержите нас - каждый вклад важен!
Поддержите нас - каждый вклад важен!

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

Вы просматриваете документ для прошлой версии.
Рассмотрите возможность обновления вашего проекта до актуальной версии 11.x. Почему это важно?

Введение

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 автоматически отключается при запуске тестов.

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

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

<?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 для установки значений файлов Cookies перед отправкой запроса. Метод 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 также содержит несколько хелперов для тестирования 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
{
    /**
     * Отвлеченный пример функционального теста.
     */
    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);

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

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('victoria@gmail.com'))
                 ->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 принимает замыкание, получающее другой экземпляр AssertableJson, который можно использовать для создания утверждений относительно первого объекта коллекции JSON:

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

Уровень вложенности утверждения относительно коллекций 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')
                     ->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('victoria@gmail.com'))
                     ->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(): 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 и компоненты

Если необходимо, вы можете использовать метод 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 содержит множество своих методов утверждения, которые вы можете использовать при тестировании вашего приложения. К этим утверждениям можно получить доступ в ответе, возвращаемом тестовыми методами json, get, post, put, и delete:

assertBadRequest

Утверждает, что ответ имеет код 400 состояния HTTP – bad request:

$response->assertBadRequest();

assertAccepted

Утверждает, что ответ имеет код 202 состояния HTTP – accepted:

$response->assertAccepted();

assertConflict

Утверждает, что ответ имеет код 409 состояния HTTP – conflict:

$response->assertConflict();

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

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

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

$response->assertCookieExpired($cookieName);

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

$response->assertCookieNotExpired($cookieName);

Утверждает, что ответ не содержит переданный 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();

assertFound

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

$response->assertFound();

assertGone

Утверждает, что ответ имеет код 420 состояния HTTP – gone:

$response->assertGone();

assertHeader

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

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

assertHeaderMissing

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

$response->assertHeaderMissing($headerName);

assertInternalServerError

Утверждает, что ответ имеет код 500 состояния HTTP – Internal Server Error:

$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

Утверждает, что ответ имеет код 405 состояния HTTP – method not allowed:

$response->assertMethodNotAllowed();

assertMovedPermanently

Утверждает, что ответ имеет код 301 состояния HTTP – moved permanently:

$response->assertMovedPermanently();

assertLocation

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

$response->assertLocation($uri);

assertContent

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

$response->assertContent($value);

assertNoContent

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

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

assertStreamedContent

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

$response->assertStreamedContent($value);

assertNotFound

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

$response->assertNotFound();

assertOk

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

$response->assertOk();

assertPaymentRequired

Утверждает, что ответ имеет код 402 состояния HTTP – payment required:

$response->assertPaymentRequired();

Утверждает, что ответ содержит переданный незашифрованный 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

Утверждает, что ответ имеет код 408 состояния HTTP – request timeout:

$response->assertRequestTimeout();

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

assertServerError

Утверждает, что ответ имеет код состояния HTTP соответствующий ошибке сервера – >= 500 , < 600 :

$response->assertServerError();

assertServiceUnavailable

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

$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 в конкретной коллекции ошибок. Если $keys является ассоциативным массивом, убедитесь, что сессия содержит конкретное сообщение об ошибке (значение) для каждого поля (ключа) в коллекции ошибок:

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

assertSessionHasNoErrors

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

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

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

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

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

assertSessionMissing

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

$response->assertSessionMissing($key);

assertStatus

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

$response->assertStatus($code);

assertSuccessful

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

$response->assertSuccessful();

assertTooManyRequests

Утверждает, что ответ имеет код 429 состояния HTTP – too many requests:

$response->assertTooManyRequests();

assertUnauthorized

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

$response->assertUnauthorized();

assertUnprocessable

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

$response->assertUnprocessable();

assertUnsupportedMediaType

Утверждает, что ответ имеет код 415 состояния HTTP – unsupported media type:

$response->assertUnsupportedMediaType()

assertValid

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

// Assert that no validation errors are present...
$response->assertValid();

// Assert that the given keys do not have validation errors...
$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' => 'taylor@example.com,',
]);

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 предоставляет два основных метода утверждения, связанных с валидацией, которые вы можете использовать, чтобы убедиться, что данные, предоставленные в вашем запросе, являются валидными или невалидными.

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