- Введение
- Выполнение запросов
- Тестирование JSON API
- Тестирование загрузки файлов
- Тестирование шаблонной системы
- Доступные утверждения
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);
}
}
Вы можете использовать методы 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();
}
}
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 есть другие свойства, этот тест все равно будет проходить, пока присутствует переданный фрагмент.
Как упоминалось ранее, метод 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 содержит данные по указанному пути, вам следует использовать метод 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');
}
}
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
в конце нашей цепочки утверждений. Этот метод сообщает Laravel, что в объекте JSON могут присутствовать другие атрибуты. Если метод etc
не используется, то тест завершится неудачно, если в объекте JSON существуют другие атрибуты, для которых вы не сделали утверждений.
Цель такого поведения – защитить вас от непреднамеренного раскрытия конфиденциальной информации в ваших ответах JSON, заставив вас либо явно сделать утверждение относительно атрибута, либо явно разрешить дополнительные атрибуты с помощью метода etc
.
Часто ваш маршрут возвращает ответ 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, которым назначены именованные ключи:
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 имеют определенный тип. Класс 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. Подобно методу 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
Утверждение о том, что ответ содержит переданный cookie:
$response->assertCookie($cookieName, $value = null);
Утверждение о том, что в ответе содержится переданный cookie и срок его действия истек:
$response->assertCookieExpired($cookieName);
Утверждение о том, что в ответе содержится переданный cookie и срок его действия не истек:
$response->assertCookieNotExpired($cookieName);
Утверждение о том, что ответ не содержит переданный cookie:
$response->assertCookieMissing($cookieName);
Утверждение о том, что ответ имеет код 201
состояния HTTP:
$response->assertCreated();
Утверждение о том, что переданная строка не содержится в ответе, возвращаемом приложением. Это утверждение автоматически экранирует переданную строку, если вы не передадите второй аргумент как false
:
$response->assertDontSee($value, $escaped = true);
Утверждение о том, что переданная строка не содержится в тексте ответа. Это утверждение автоматически экранирует переданную строку, если вы не передадите второй аргумент как false
. Этот метод передаст содержимое ответа PHP-функции strip_tags
перед тем, как выполнить утверждение:
$response->assertDontSeeText($value, $escaped = true);
Утверждение о том, что ответ является «загрузкой». Обычно это означает, что был вызван маршрут, который вернул ответ Response::download
, BinaryFileResponse
или Storage::download
:
$response->assertDownload();
При желании вы можете утверждать, что загружаемому файлу было присвоено указанное имя:
$response->assertDownload('image.jpg');
Утверждение о том, что ответ содержит точное совпадение указанных данных JSON:
$response->assertExactJson(array $data);
Утверждение о том, что ответ имеет код 403
состояния HTTP – forbidden
:
$response->assertForbidden();
Утверждение о том, что переданный заголовок и значение присутствуют в ответе:
$response->assertHeader($headerName, $value = null);
Утверждение о том, что переданный заголовок отсутствует в ответе:
$response->assertHeaderMissing($headerName);
Утверждение о том, что ответ содержит указанные данные JSON:
$response->assertJson(array $data, $strict = false);
Метод assertJson
преобразует ответ в массив и использует PHPUnit::assertArraySubset
для проверки того, что переданный массив существует в ответе JSON, возвращаемом приложением. Итак, если в ответе JSON есть другие свойства, этот тест все равно будет проходить, пока присутствует переданный фрагмент.
Утверждение о том, что ответ JSON имеет массив с ожидаемым количеством элементов указанного ключа:
$response->assertJsonCount($count, $key = null);
Утверждение о том, что ответ содержит указанные данные JSON в любом месте ответа:
Route::get('/users', function () {
return [
'users' => [
[
'name' => 'Taylor Otwell',
],
],
];
});
$response->assertJsonFragment(['name' => 'Taylor Otwell']);
Утверждение о том, что ответ не содержит указанных данных JSON:
$response->assertJsonMissing(array $data);
Утверждение о том, что ответ не содержит точных указанных данных JSON:
$response->assertJsonMissingExact(array $data);
Утверждение о том, что ответ не содержит ошибок валидации JSON для переданных ключей:
$response->assertJsonMissingValidationErrors($keys);
Утверждение о том, что ответ содержит конкретные данные по указанному пути:
$response->assertJsonPath($path, $expectedValue);
Например, если ответ JSON, возвращаемый вашим приложением, содержит следующие данные:
{
"user": {
"name": "Steve Schoger"
}
}
Вы можете утверждать, что свойство name
объекта user
соответствует переданному значению следующим образом:
$response->assertJsonPath('user.name', 'Steve Schoger');
Утверждение о том, что ответ имеет переданную структуру 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'
]
]
]);
Утверждение о том, что ответ содержит переданные ошибки валидации JSON для переданных ключей. Этот метод следует использовать при утверждении ответов, в которых ошибки валидации возвращаются как структура JSON, а не кратковременно передаются в сесиию:
$response->assertJsonValidationErrors(array $data);
Утверждение о том, что ответ имеет переданное значение URI в заголовке Location
:
$response->assertLocation($uri);
Утверждение о том, что ответ имеет код 204
состояния HTTP – no content
:
$response->assertNoContent($status = 204);
Утверждение о том, что ответ имеет код 404
состояния HTTP – not found
:
$response->assertNotFound();
Утверждение о том, что ответ имеет код 200
состояния HTTP – OK
:
$response->assertOk();
Утверждение о том, что ответ содержит переданный незашифрованный cookie:
$response->assertPlainCookie($cookieName, $value = null);
Утверждение о том, что ответ является перенаправлением на указанный URI:
$response->assertRedirect($uri);
Утверждение о том, что ответ является перенаправлением на указанный подписанный маршрут:
$response->assertRedirectToSignedRoute($name = null, $parameters = []);
Утверждение о том, что переданная строка содержится в ответе. Это утверждение автоматически экранирует переданную строку, если вы не передадите второй аргумент как false
:
$response->assertSee($value, $escaped = true);
Утверждение о том, что переданные строки содержатся в ответе в указанном порядке. Это утверждение автоматически экранирует переданные строки, если вы не передадите второй аргумент как false
:
$response->assertSeeInOrder(array $values, $escaped = true);
Утверждение о том, что переданная строка содержится в тексте ответа. Это утверждение автоматически экранирует переданную строку, если вы не передадите второй аргумент как false
. Этот метод передаст содержимое ответа PHP-функции strip_tags
перед тем, как выполнить утверждение:
$response->assertSeeText($value, $escaped = true);
Утверждение о том, что переданные строки содержатся в тексте ответа в указанном порядке. Это утверждение автоматически экранирует переданные строки, если вы не передадите второй аргумент как false
. Этот метод передаст содержимое ответа PHP-функции strip_tags
перед тем, как выполнить утверждение:
$response->assertSeeTextInOrder(array $values, $escaped = true);
Утверждение о том, что сессия содержит переданный фрагмент данных:
$response->assertSessionHas($key, $value = null);
Утверждение о том, что сессия имеет переданное значение в массиве входящих данных кратковременного сохранения:
$response->assertSessionHasInput($key, $value = null);
Утверждение о том, что сессия содержит переданный массив пар ключ / значение:
$response->assertSessionHasAll(array $data);
Например, если сессия вашего приложения содержит ключи name
и status
, вы можете утверждать, что оба они существуют и имеют указанные значения, например:
$response->assertSessionHasAll([
'name' => 'Taylor Otwell',
'status' => 'active',
]);
Утверждение о том, что сессия содержит ошибку для переданных $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.'
]);
Утверждение о том, что сессия содержит ошибку для переданных $keys
в конкретной коллекции ошибок. Если $keys
является ассоциативным массивом, убедитесь, что сессия содержит конкретное сообщение об ошибке (значение) для каждого поля (ключа) в коллекции ошибок:
$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);
Утверждение о том, что в сессии нет ошибок валидации:
$response->assertSessionHasNoErrors();
Утверждение о том, что в сессии нет ошибок валидации для переданных ключей:
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');
Утверждение о том, что сессия не содержит переданного ключа:
$response->assertSessionMissing($key);
Утверждение о том, что ответ имеет указанный код $code
состояния HTTP:
$response->assertStatus($code);
Утверждение о том, что ответ имеет код >= 200
и < 300
состояния HTTP – successful
:
$response->assertSuccessful();
Утверждение о том, что ответ имеет код 401
состояния HTTP – unauthorized
:
$response->assertUnauthorized();
Утверждение о том, что ответ не содержит ошибок валидации для переданных ключей. Этот метод может использоваться для утверждений относительно ответов, в которых ошибки валидации возвращаются в виде структуры JSON или где ошибки валидации были переданы в сессию:
// Утверждение об отсутствии ошибок валидации ...
$response->assertValid();
// Утверждение об отсутствии ошибок валидации для переданных ключей ...
$response->assertValid(['name', 'email']);
Утверждение о том, что ответ содержит ошибки валидации для переданных ключей. Этот метод может использоваться для утверждений относительно ответов, в которых ошибки валидации возвращаются в виде структуры JSON или где ошибки валидации были переданы в сессию:
$response->assertInvalid(['name', 'email']);
Вы также можете использовать утверждение, что переданный ключ имеет конкретное сообщение об ошибке валидации. При этом вы можете передать как сообщение полностью, так и его небольшую часть:
$response->assertInvalid([
'name' => 'The name field is required.',
'email' => 'valid email address',
]);
Утверждение о том, что шаблон ответа содержит переданный фрагмент данных:
$response->assertViewHas($key, $value = null);
Передача замыкания в качестве второго аргумента методу assertViewHas
позволит вам выполнять утверждения в отношении определенной части данных представления:
$response->assertViewHas('user', function (User $user) {
return $user->name === 'Taylor';
});
Кроме того, данные шаблона могут быть доступны как переменные массива в ответе, что позволяет вам удобно инспектировать их:
$this->assertEquals('Taylor', $response['name']);
Утверждение о том, что шаблон ответа содержит переданный список данных:
$response->assertViewHasAll(array $data);
Этот метод может использоваться, чтобы утверждать, что шаблон просто содержит данные с соответствующими переданными ключами:
$response->assertViewHasAll([
'name',
'email',
]);
Или вы можете утверждать, что данные шаблона присутствуют и имеют определенные значения:
$response->assertViewHasAll([
'name' => 'Taylor Otwell',
'email' => '[email protected],',
]);
Утверждение о том, что маршрутом был возвращен указанный шаблон:
$response->assertViewIs($value);
Утверждение о том, что переданный ключ данных не был доступен для шаблона, возвращенного ответом приложения:
$response->assertViewMissing($key);
Laravel также содержит множество утверждений, связанных с аутентификацией, которые вы можете использовать в функциональных тестах вашего приложения. Обратите внимание, что эти методы вызываются в самом тестовом классе, а не в экземпляре Illuminate\Testing\TestResponse
, возвращаемом такими методами, как get
и post
.
Утверждение о том, что пользователь аутентифицирован:
$this->assertAuthenticated($guard = null);
Утверждение о том, что пользователь не аутентифицирован:
$this->assertGuest($guard = null);
Утверждение о том, что конкретный пользователь аутентифицирован:
$this->assertAuthenticatedAs($user, $guard = null);