Тестирование · Тесты HTTP
- Введение
- Выполнение запросов
- Настройка заголовков запросов
- Cookies
- Сессия / Аутентификация
- Отладка ответов
- Обработка исключений
- Тестирование JSON API
- Последовательное тестирование JSON
- Тестирование загрузки файлов
- Тестирование шаблонной системы
- Отрисовка Blade и компоненты
- Доступные утверждения
- Утверждения ответов
- Утверждения аутентификации
- Утверждения валидации
Введение
Laravel предлагает гибкий API в составе вашего приложения для выполнения HTTP-запросов и получения информации об ответах. Например, взгляните на следующий функциональный тест:
<?php
test('the application returns a successful response', function () {
$response = $this->get('/');
$response->assertStatus(200);
});
<?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
test('basic request', function () {
$response = $this->get('/');
$response->assertStatus(200);
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic test example.
*/
public function test_a_basic_request(): void
{
$response = $this->get('/');
$response->assertStatus(200);
}
}
Как правило, каждый из ваших тестов должен выполнять только один запрос к вашему приложению. Неожиданное поведение может возникнуть, если в рамках одного метода теста выполняется несколько запросов.
Для удобства посредник CSRF автоматически отключается при запуске тестов.
Настройка заголовков запросов
Вы можете использовать метод withHeaders для настройки заголовков запроса перед его отправкой в приложение. Этот метод позволяет вам добавлять в запрос любые пользовательские заголовки:
<?php
test('interacting with headers', function () {
$response = $this->withHeaders([
'X-Header' => 'Value',
])->post('/user', ['name' => 'Sally']);
$response->assertStatus(201);
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic functional test example.
*/
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
test('interacting with cookies', function () {
$response = $this->withCookie('color', 'blue')->get('/');
$response = $this->withCookies([
'color' => 'blue',
'name' => 'Taylor',
])->get('/');
//
});
<?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
test('interacting with the session', function () {
$response = $this->withSession(['banned' => false])->get('/');
//
});
<?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
use App\Models\User;
test('an action that requires authentication', function () {
$user = User::factory()->create();
$response = $this->actingAs($user)
->withSession(['banned' => false])
->get('/');
//
});
<?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
test('basic test', function () {
$response = $this->get('/');
$response->dumpHeaders();
$response->dumpSession();
$response->dump();
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic test example.
*/
public function test_basic_test(): void
{
$response = $this->get('/');
$response->dumpHeaders();
$response->dumpSession();
$response->dump();
}
}
В качестве альтернативы вы можете использовать методы dd, ddHeaders и ddSession, чтобы выгрузить информацию об ответе и затем остановить выполнение:
<?php
test('basic test', function () {
$response = $this->get('/');
$response->ddHeaders();
$response->ddSession();
$response->dd();
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic test example.
*/
public function test_basic_test(): void
{
$response = $this->get('/');
$response->ddHeaders();
$response->ddSession();
$response->dd();
}
}
Обработка исключений
Иногда вам может понадобиться проверить, выдает ли ваше приложение определенное исключение. Для этого вы можете «подделать» обработчик исключений через фасад Exceptions. После того как обработчик исключений был подделан, вы можете использовать методы assertReported и assertNotReported для создания утверждений против исключений, которые были созданы во время запроса:
<?php
use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
test('exception is thrown', function () {
Exceptions::fake();
$response = $this->get('/order/1');
// Assert an exception was thrown...
Exceptions::assertReported(InvalidOrderException::class);
// Assert against the exception...
Exceptions::assertReported(function (InvalidOrderException $e) {
return $e->getMessage() === 'The order was invalid.';
});
});
<?php
namespace Tests\Feature;
use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic test example.
*/
public function test_exception_is_thrown(): void
{
Exceptions::fake();
$response = $this->get('/');
// Assert an exception was thrown...
Exceptions::assertReported(InvalidOrderException::class);
// Assert against the exception...
Exceptions::assertReported(function (InvalidOrderException $e) {
return $e->getMessage() === 'The order was invalid.';
});
}
}
Методы assertNotReported и assertNothingReported могут использоваться для подтверждения того, что данное исключение не было создано во время запроса или что никаких исключений не было создано:
Exceptions::assertNotReported(InvalidOrderException::class);
Exceptions::assertNothingReported();
Вы можете полностью отключить обработку исключений для данного запроса, вызвав метод withoutExceptionHandling перед отправкой запроса:
$response = $this->withoutExceptionHandling()->get('/');
Кроме того, если вы хотите убедиться, что ваше приложение не использует функции, считающиеся устаревшими языком PHP или библиотеками, которые использует ваше приложение, вы можете вызвать метод withoutDeprecationHandling перед тем, как сделать свой запрос. Когда обработка устаревания отключена, предупреждения об устаревании будут преобразованы в исключения, что приведет к сбою вашего теста:
$response = $this->withoutDeprecationHandling()->get('/');
Метод assertThrows можно использовать для проверки того, что код внутри заданного замыкания генерирует исключение указанного типа:
$this->assertThrows(
fn () => (new ProcessOrder)->execute(),
OrderInvalid::class
);
Если вы хотите проверить и сделать утверждения против выброшенного исключения, вы можете предоставить замыкание в качестве второго аргумента метода assertThrows:
$this->assertThrows(
fn () => (new ProcessOrder)->execute(),
fn (OrderInvalid $e) => $e->orderId() === 123;
);
Тестирование JSON API
Laravel также содержит несколько хелперов для тестирования API-интерфейсов JSON и их ответов. Например, методы json, getJson, postJson, putJson, patchJson, deleteJson, и optionsJson могут использоваться для отправки запросов JSON с различными HTTP-командами. Вы также можете передавать данные и заголовки этим методам. Для начала давайте напишем тест, чтобы сделать запрос POST к /api/user и убедиться, что в JSON были возвращены ожидаемые данные:
<?php
test('making an api request', function () {
$response = $this->postJson('/api/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertJson([
'created' => true,
]);
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic functional test example.
*/
public function test_making_an_api_request(): void
{
$response = $this->postJson('/api/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertJson([
'created' => true,
]);
}
}
Кроме того, к данным ответа JSON можно получить доступ как к переменным массива в ответе, что позволяет удобно проверять отдельные значения, возвращаемые в JSON-ответе:
expect($response['created'])->toBeTrue();
$this->assertTrue($response['created']);
Метод
assertJsonпреобразует ответ в массив для проверки того, что переданный массив существует в ответе JSON, возвращаемом приложением. Итак, если в ответе JSON есть другие свойства, этот тест все равно будет проходить, пока присутствует переданный фрагмент.
Утверждение точных совпадений JSON
Как упоминалось ранее, метод assertJson используется для подтверждения наличия фрагмента JSON в ответе JSON. Если вы хотите убедиться, что данный массив в точности соответствует JSON, возвращаемому вашим приложением, вы должны использовать метод assertExactJson:
<?php
test('asserting an exact json match', function () {
$response = $this->postJson('/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertExactJson([
'created' => true,
]);
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic functional test example.
*/
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
test('asserting a json path value', function () {
$response = $this->postJson('/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertJsonPath('team.owner.name', 'Darian');
});
<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* A basic functional test example.
*/
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;
test('fluent json', function () {
$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()
);
});
use Illuminate\Testing\Fluent\AssertableJson;
/**
* A basic functional test example.
*/
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')
->where('email', fn (string $email) => str($email)->is('victoria@gmail.com'))
->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
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
test('avatars can be uploaded', function () {
Storage::fake('avatars');
$file = UploadedFile::fake()->image('avatar.jpg');
$response = $this->post('/avatar', [
'avatar' => $file,
]);
Storage::disk('avatars')->assertExists($file->hashName());
});
<?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
test('a welcome view can be rendered', function () {
$view = $this->view('welcome', ['name' => 'Taylor']);
$view->assertSee('Taylor');
});
<?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:
- assertAccepted
- assertBadRequest
- assertConflict
- assertCookie
- assertCookieExpired
- assertCookieNotExpired
- assertCookieMissing
- assertCreated
- assertDontSee
- assertDontSeeText
- assertDownload
- assertExactJson
- assertExactJsonStructure
- 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
Утверждает, что ответ имеет код 400 состояния HTTP – bad request:
$response->assertBadRequest();
assertAccepted
Утверждает, что ответ имеет код 202 состояния HTTP – accepted:
$response->assertAccepted();
assertConflict
Утверждает, что ответ имеет код 409 состояния HTTP – conflict:
$response->assertConflict();
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);
assertExactJsonStructure
Убедитесь, что ответ содержит точное соответствие заданной структуре JSON:
$response->assertExactJsonStructure(array $data);
Этот метод является более строгим вариантом assertJsonStructure. В отличие от assertJsonStructure, этот метод завершится ошибкой, если ответ содержит какие-либо ключи, которые явно не включены в ожидаемую структуру JSON.
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 преобразует ответ в массив для проверки того, что переданный массив существует в ответе 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();
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
Утверждает, что ответ имеет код 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 или ошибки проверки были переданы в сессию:
// Утверждает, что ошибок проверки нет...
$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';
});
Кроме того, данные шаблона могут быть доступны как переменные массива в ответе, что позволяет вам удобно инспектировать их:
expect($response['name'])->toBe('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',
]);
