Laravel fornece uma API muito fluente para fazer requisições HTTP à sua aplicação e examinar as respostas. Por exemplo, veja o teste de recurso abaixo:
::: code-group
<?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
{
/**
* Um exemplo de teste básico.
*/
public function test_the_application_returns_a_successful_response(): void
{
$response = $this->get('/');
$response->assertStatus(200);
}
}:::
O método get faz uma solicitação GET para o aplicativo, enquanto o método assertStatus afirma que a resposta retornada deve ter o código de status HTTP especificado. Além desta afirmação simples, o Laravel também possui uma variedade de afirmações para inspecionar os cabeçalhos de resposta, conteúdo, estrutura JSON e muito mais.
Para fazer uma requisição ao seu aplicativo, você pode invocar os métodos get, post, put, patch ou delete dentro do seu teste. Esses métodos não fazem realmente uma requisição HTTP para o seu aplicativo. Em vez disso, todo o pedido de rede é simulado internamente.
Em vez de retornar uma instância de Illuminate/Http/Response, os métodos de teste retornam uma instância de Illuminate/Testing/TestResponse que fornece um variedade de afirmações úteis que permitem inspecionar as respostas do seu aplicativo:
::: code-group
<?php
test('basic request', function () {
$response = $this->get('/');
$response->assertStatus(200);
});<?php
namespace Tests\Feature;
use Tests\TestCase;
class ExampleTest extends TestCase
{
/**
* Um exemplo de teste básico.
*/
public function test_a_basic_request(): void
{
$response = $this->get('/');
$response->assertStatus(200);
}
}:::
Em geral, cada um de seus testes deveria fazer apenas uma solicitação à sua aplicação. Comportamento inesperado pode ocorrer se várias solicitações forem executadas em um único método de teste.
::: info Nota Para conveniência, o middleware CSRF é desativado automaticamente quando os testes são executados. :::
Você pode usar o método withHeaders para personalizar os cabeçalhos do pedido antes de ser enviado ao aplicativo. Este método permite-lhe adicionar quaisquer cabeçalhos personalizados que desejar à solicitação:
::: code-group
<?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
{
/**
* Um exemplo básico de teste funcional.
*/
public function test_interacting_with_headers(): void
{
$response = $this->withHeaders([
'X-Header' => 'Value',
])->post('/user', ['name' => 'Sally']);
$response->assertStatus(201);
}
}:::
Você pode usar os métodos withCookie ou withCookies para definir valores de cookies antes de fazer uma requisição. O método withCookie aceita um nome e valor do cookie como seus dois argumentos, enquanto o método withCookies aceita uma matriz de pares de nomes/valores:
::: cod-group
<?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('/');
//
}
}:::
O Laravel oferece vários ajudantes para interagir com as sessões durante os testes http. Primeiro, você pode definir os dados da sessão em um determinado array usando o método withSession. Isso é útil para carregar a sessão com os dados antes de enviar uma solicitação ao seu aplicativo.
::: code-group
<?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('/');
//
}
}:::
O Laravel utiliza tipicamente sua sessão para manter o estado do usuário atualmente autenticado. Portanto, o método de ajuda actingAs fornece um meio simples de autenticar um determinado usuário como o usuário atual. Por exemplo, podemos usar uma fábrica de modelo para gerar e autenticar um usuário:
::: code-group
<?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('/');
//
}
}:::
Você também pode especificar qual guarda deve ser usado para autenticar o usuário fornecido passando o nome do guarda como o segundo argumento para o método actingAs. O guarda que é fornecido para o método actingAs também se tornará o guarda padrão durante o teste:
$this->actingAs($user, 'web')Após fazer uma solicitação de teste para sua aplicação, os métodos dump, dumpHeaders e dumpSession podem ser usados para examinar e depurar o conteúdo da resposta:
::: code-group
<?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
{
/**
* Um exemplo de teste básico.
*/
public function test_basic_test(): void
{
$response = $this->get('/');
$response->dumpHeaders();
$response->dumpSession();
$response->dump();
}
}:::
Alternativamente, você pode usar os métodos dd, ddHeaders e ddSession para dar um dump de informações sobre a resposta e então parar a execução.
::: code-group
<?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
{
/**
* Um exemplo de teste básico.
*/
public function test_basic_test(): void
{
$response = $this->get('/');
$response->ddHeaders();
$response->ddSession();
$response->dd();
}
}:::
Às vezes, você pode precisar testar se seu aplicativo está lançando uma exceção específica. Para fazer isso, você pode "falsificar" o manipulador de exceções por meio da facade Exceptions. Depois que o manipulador de exceções for falsificado, você pode utilizar os métodos assertReported e assertNotReported para fazer asserções contra exceções que foram lançadas durante a solicitação:
::: code-group
<?php
use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
test('exception is thrown', function () {
Exceptions::fake();
$response = $this->get('/order/1');
// Afirme que uma exceção foi lançada...
Exceptions::assertReported(InvalidOrderException::class);
// Afirme contra a exceção...
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
{
/**
* Um exemplo de teste básico.
*/
public function test_exception_is_thrown(): void
{
Exceptions::fake();
$response = $this->get('/');
// Afirme que uma exceção foi lançada...
Exceptions::assertReported(InvalidOrderException::class);
// Afirme contra a exceção...
Exceptions::assertReported(function (InvalidOrderException $e) {
return $e->getMessage() === 'The order was invalid.';
});
}
}:::
Os métodos assertNotReported e assertNothingReported podem ser usados para afirmar que uma exceção foi ou não lançada durante a requisição, respectivamente.
Exceptions::assertNotReported(InvalidOrderException::class);
Exceptions::assertNothingReported();Você pode desativar completamente a manipulação de exceções para uma solicitação dada invocando o método withoutExceptionHandling antes de fazer sua solicitação:
$response = $this->withoutExceptionHandling()->get('/');Além disso, se você gostaria de garantir que seu aplicativo não está usando recursos que foram descontinuados pelo PHP ou as bibliotecas que seu aplicativo está usando, você pode invocar o método withoutDeprecationHandling antes de fazer sua solicitação. Quando a manipulação de desuso é desativada, avisos de depreciações serão convertidos em exceções, fazendo assim seu teste falhar:
$response = $this->withoutDeprecationHandling()->get('/');O método assertThrows pode ser usado para verificar se um determinado código dentro de uma função anônima lança uma exceção do tipo especificado:
$this->assertThrows(
fn () => (new ProcessOrder)->execute(),
OrderInvalid::class
);Laravel também fornece vários auxiliares para testes de APIs JSON e suas respostas. Por exemplo, os métodos json, getJson, postJson, putJson, patchJson, deleteJson e optionsJson podem ser usados para fazer solicitações JSON com verbos HTTP diferentes. Você também pode passar facilmente dados e cabeçalhos a esses métodos. Para começar, vamos escrever um teste para fazer uma solicitação POST em /api/user e afirmar que os dados JSON esperados foram retornados:
::: code-group
<?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
{
/**
* Um exemplo básico de teste funcional.
*/
public function test_making_an_api_request(): void
{
$response = $this->postJson('/api/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertJson([
'created' => true,
]);
}
}:::
Além disso, os dados de resposta JSON podem ser acessados como variáveis de matriz na resposta, tornando conveniente para você inspecionar os valores individuais retornados dentro de uma resposta JSON.
::: code-group
expect($response['created'])->toBeTrue();$this->assertTrue($response['created']);:::
::: info Nota
O método assertJson converte a resposta em um array e utiliza o PHPUnit::assertArraySubset para verificar se o array fornecido existe na resposta JSON retornada pela aplicação. Assim, se houver outras propriedades na resposta JSON, esse teste ainda passará desde que o fragmento fornecido esteja presente.
:::
Como mencionado anteriormente, o método assertJson pode ser usado para afirmar que uma parte do arquivo JSON existe dentro do JSON da resposta. Se você deseja verificar se um determinado array corresponde exatamente ao JSON retornado pelo seu aplicativo, você deve usar o método assertExactJson:
::: code-group
<?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
{
/**
* Um exemplo básico de teste funcional.
*/
public function test_asserting_an_exact_json_match(): void
{
$response = $this->postJson('/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertExactJson([
'created' => true,
]);
}
}:::
Se você gostaria de verificar que a resposta JSON contém os dados dados em um caminho especificado, você deve usar o método assertJsonPath:
::: code-group
<?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
{
/**
* Um exemplo básico de teste funcional.
*/
public function test_asserting_a_json_paths_value(): void
{
$response = $this->postJson('/user', ['name' => 'Sally']);
$response
->assertStatus(201)
->assertJsonPath('team.owner.name', 'Darian');
}
}:::
O método assertJsonPath também aceita um closure que pode ser usado para determinar dinamicamente se a afirmação deve passar:
$response->assertJsonPath('team.owner.name', fn (string $name) => strlen($name) >= 3);Laravel também oferece um belo jeito de testar fluentemente as respostas JSON da sua aplicação. Para começar, passe uma função para o método assertJson. Esta função será invocada com uma instância de Illuminate\Testing\Fluent\AssertableJson, que pode ser utilizada para fazer afirmações sobre o JSON retornado pela sua aplicação. O método where pode ser usado para fazer afirmações sobre um atributo específico do JSON, enquanto o método missing pode ser utilizado para afirmar que um atributo específico está ausente do JSON:
::: code-group
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;
/**
* Um exemplo básico de teste funcional.
*/
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()
);
}:::
No exemplo acima você pode ter notado que invocamos o método etc no final de nossa cadeia de afirmações. Este método informa ao Laravel que pode haver outros atributos presentes no objeto JSON. Se o método etc não for utilizado, a prova vai falhar se houver outros atributos que você não fez afirmações contra no objeto JSON.
A intenção por trás desse comportamento é proteger você de expor acidentalmente informações confidenciais nas suas respostas JSON, forçando-o a fazer uma afirmação explícita contra o atributo ou permitir explicitamente atributos adicionais pelo método etc.
No entanto, você deve estar ciente de que não incluir o método etc em sua cadeia de asserção não garante que atributos adicionais não estão sendo adicionados a matrizes aninhadas dentro do seu objeto JSON. O método etc só garante que não há atributos adicionais na camada de aninhamento em que o método etc é invocado.
Para afirmar que um atributo está presente ou ausente, você pode usar os métodos has e missing:
$response->assertJson(fn (AssertableJson $json) =>
$json->has('data')
->missing('message')
);Além disso, os métodos hasAll e missingAll permitem afirmar a presença ou ausência de vários atributos simultaneamente:
$response->assertJson(fn (AssertableJson $json) =>
$json->hasAll(['status', 'data'])
->missingAll(['message', 'code'])
);Você pode usar o método hasAny para determinar se, pelo menos um dos atributos dados está presente:
$response->assertJson(fn (AssertableJson $json) =>
$json->has('status')
->hasAny('data', 'message', 'code')
);Sua rota pode retornar uma resposta em JSON que contenha múltiplos itens, como múltiplos usuários:
Route::get('/users', function () {
return User::all();
});Nestas situações, podemos usar o método has do objeto JSON para fazer afirmações sobre os usuários incluídos na resposta. Por exemplo, vamos afirmar que a resposta JSON contém três usuários. Em seguida, faremos algumas afirmações sobre o primeiro usuário na coleção usando o método first. O método first aceita uma função de closure que recebe outra string JSON verificável, que podemos usar para fazer afirmações sobre o primeiro objeto na coleção 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()
)
);Às vezes, as rotas de sua aplicação vão retornar coleções JSON com chaves nomeadas.
Route::get('/users', function () {
return [
'meta' => [...],
'users' => User::all(),
];
})Ao testar essas rotas, você pode usar o método has para fazer assert contra o número de itens na coleção. Além disso, você pode usar o método has para fazer escopo de uma cadeia de assertivas:
$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()
)
);No entanto, em vez de fazer duas chamadas separadas para o método has para fazer assert contra a coleção users, você pode fazer uma única chamada que fornece um closure como seu terceiro parâmetro. Ao fazer isso, o closure será automaticamente invocado e terá como escopo o primeiro item na coleção:
$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()
)
);Você talvez só queira afirmar que as propriedades na resposta JSON são de um determinado tipo. A classe Illuminate\Testing\Fluent\AssertableJson fornece os métodos whereType e whereAllType para fazer exatamente isso:
$response->assertJson(fn (AssertableJson $json) =>
$json->whereType('id', 'integer')
->whereAllType([
'users.0.name' => 'string',
'meta' => 'array'
])
);Você pode especificar vários tipos usando o caractere | ou passando uma matriz de tipos como segundo parâmetro para o método whereType. A afirmação será bem sucedida se o valor da resposta for qualquer um dos tipos listados.
$response->assertJson(fn (AssertableJson $json) =>
$json->whereType('name', 'string|null')
->whereType('id', ['string', 'integer'])
);Os métodos whereType e whereAllType reconhecem os seguintes tipos: string, integer, double, boolean, array e null.
A classe Illuminate\Http\UploadedFile oferece um método fake, que pode ser usado para gerar arquivos ou imagens falsas para testes. Isso, combinado com o método fake da facade Storage, simplifica muito a realização de testes em envios de arquivos. Por exemplo, você pode combinar essas duas funcionalidades para testar facilmente um formulário de upload de avatar:
::: code-group
<?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());
}
}:::
Se você gostaria de afirmar que um determinado arquivo não existe, você pode usar o método assertMissing fornecido pela facade Storage:
Storage::fake('avatars');
// ...
Storage::disk('avatars')->assertMissing('missing.jpg');Ao criar arquivos usando o método fake fornecido pela classe UploadedFile você pode especificar a largura, altura e tamanho da imagem (em kilobytes), de forma a testar melhor as regras de validação do seu aplicativo.
UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);Além de criar imagens, você pode criar arquivos do tipo que quiser usando o método create:
UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);Se necessário, você pode passar um argumento mime-type para o método para definir explicitamente o tipo de MIME que deve ser retornado pelo arquivo:
UploadedFile::fake()->create(
'document.pdf', $sizeInKilobytes, 'application/pdf'
);O Laravel também permite renderizar uma visualização sem fazer um pedido HTTP simulado para o aplicativo. Para fazer isso, você pode chamar o método view dentro de seu teste. O método view aceita o nome da visualização e uma matriz opcional de dados. O método retorna uma instância de Illuminate\Testing\TestView, que oferece vários métodos para fazer convenientemente afirmações sobre o conteúdo da visualização:
::: code-group
<?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');
}
}:::
A classe TestView fornece os seguintes métodos de afirmação: assertSee, assertSeeInOrder, assertSeeText, assertSeeTextInOrder, assertDontSee e assertDontSeeText.
Se necessário, você pode obter o conteúdo bruto da visualização renderizada convertendo a instância TestView para um:
$contents = (string) $this->view('welcome');Algumas visualizações podem depender de erros compartilhados no global error bag fornecido pelo Laravel. Para hidratar o error bag com mensagens de erro, você pode usar o método withViewErrors:
$view = $this->withViewErrors([
'name' => ['Please provide a valid name.']
])->view('form');
$view->assertSee('Please provide a valid name.');Se necessário, você pode usar o método blade para avaliar e renderizar uma string Blade bruta. Assim como o método view, o método blade retorna uma instância de Illuminate\Testing\TestView:
$view = $this->blade(
'<x-component :name="$name" />',
['name' => 'Taylor']
);
$view->assertSee('Taylor');Você pode usar o método component para avaliar e renderizar um componente Blade . O método component retorna uma instância de Illuminate\Testing\TestComponent:
$view = $this->component(Profile::class, ['name' => 'Taylor']);
$view->assertSee('Taylor');A classe Illuminate\Testing\TestResponse do Laravel fornece uma variedade de métodos de afirmação personalizados que você pode utilizar ao testar seu aplicativo. Essas afirmações podem ser acessadas na resposta que é retornada pelos métodos json, get, post, put e delete:
assertAccepted assertBadRequest assertConflict assertCookie assertCookieExpired assertCookieNotExpired assertCookieMissing assertCreated assertDontSee assertDontSeeText assertDownload assertExactJson assertForbidden assertFound assertGone assertHeader assertHeaderMissing assertInternalServerError assertJson assertJsonCount assertJsonFragment assertJsonIsArray assertJsonIsObject assertJsonMissing assertJsonMissingExact assertJsonMissingValidationErrors assertJsonPath assertJsonMissingPath assertJsonStructure assertJsonValidationErrors assertJsonValidationErrorFor assertLocation assertMethodNotAllowed assertMovedPermanently assertContent assertNoContent assertStreamedContent assertNotFound assertOk assertPaymentRequired assertPlainCookie assertRedirect assertRedirectContains assertRedirectToRoute assertRedirectToSignedRoute assertRequestTimeout assertSee assertSeeInOrder assertSeeText assertSeeTextInOrder assertServerError assertServiceUnavailable assertSessionHas assertSessionHasInput assertSessionHasAll assertSessionHasErrors assertSessionHasErrorsIn assertSessionHasNoErrors assertSessionDoesntHaveErrors assertSessionMissing assertStatus assertSuccessful assertTooManyRequests assertUnauthorized assertUnprocessable assertUnsupportedMediaType assertValid assertInvalid assertViewHas assertViewHasAll assertViewIs assertViewMissing
Afirmar que a requisição é inválida (400) no código de estado HTTP:
$response->assertBadRequest();Afirmar que a resposta tem um código de estado HTTP aceito (202):
$response->assertAccepted();Afirme que a resposta tem um conflito (409) código de estado HTTP:
$response->assertConflict();Afirmar que a resposta contém o cookie fornecido.
$response->assertCookie($cookieName, $value = null);Afirme que a resposta contém o cookie dado e está expirado:
$response->assertCookieExpired($cookieName);Afirme que a resposta contém o cookie fornecido e não está expirado:
$response->assertCookieNotExpired($cookieName);Afirme que a resposta não contém o cookie fornecido:
$response->assertCookieMissing($cookieName);Afirme que a resposta tem o código de estado HTTP 201.
$response->assertCreated();Afirmar que a string dada não está contida na resposta retornada pelo aplicativo. Esta afirmação irá escapar automaticamente a string dada a menos que você passe um segundo argumento false:
$response->assertDontSee($value, $escaped = true);Afirme que a string fornecida não está contida no texto de resposta. Esta afirmação escapará automaticamente a string fornecida, a menos que você passe um segundo argumento false. Este método passará o conteúdo de resposta para a função strip_tags do PHP antes de fazer a afirmação:
$response->assertDontSeeText($value, $escaped = true);Afirme que a resposta é um download. Normalmente isso significa o recurso invocado que devolveu a resposta retornou Response::download, BinaryFileResponse ou Storage::download;
$response->assertDownload();Se desejar, você pode afirmar que o arquivo baixável foi atribuído um determinado nome de arquivo:
$response->assertDownload('image.jpg');Afirme que a resposta contém uma correspondência exata dos dados JSON fornecidos:
$response->assertExactJson(array $data);Afirme que o response tem um status de http 403:
$response->assertForbidden();Afirmar que a resposta tem um código de estado HTTP (302):
$response->assertFound();Afirmar que a resposta tem um (410) código de estado HTTP:
$response->assertGone();Afirmar que o cabeçalho e valor dados estão presentes na resposta.
$response->assertHeader($headerName, $value = null);Afirmar que o cabeçalho fornecido não está presente na resposta:
$response->assertHeaderMissing($headerName);Afirmar que a resposta tem o código de estado http "Internal Server Error" (500):
$response->assertInternalServerError();Afirme que a resposta contém os dados JSON fornecidos:
$response->assertJson(array $data, $strict = false);O método assertJson converte a resposta para um array e utiliza o método PHPUnit::assertArraySubset para verificar que o array dado existe na resposta json retornada pela aplicação. Portanto, se houver outras propriedades na resposta json, esta teste ainda será aprovado desde que o fragmento fornecido esteja presente.
Afirme que a resposta JSON tem uma matriz com o número esperado de itens na chave dada:
$response->assertJsonCount($count, $key = null);Afirme que a resposta contém os dados JSON fornecidos em qualquer lugar da resposta:
Route::get('/users', function () {
return [
'users' => [
[
'name' => 'Taylor Otwell',
],
],
];
});
$response->assertJsonFragment(['name' => 'Taylor Otwell']);Afirmar que a resposta JSON é um array:
$response->assertJsonIsArray();Afirmar que a resposta JSON é um objeto:
$response->assertJsonIsObject();Afirme que a resposta não contém os dados JSON fornecidos:
$response->assertJsonMissing(array $data);Afirme que a resposta não contém os dados JSON exatos:
$response->assertJsonMissingExact(array $data);Afirme que a resposta não possui erros de validação JSON para as chaves especificadas:
$response->assertJsonMissingValidationErrors($keys);::: info NOTA O método mais genérico assertValid pode ser usado para afirmar que uma resposta não tem erros de validação retornados como JSON e que não houve erros "flashados" em um armazenamento de sessão. :::
Afirme que a resposta contém os dados especificados no caminho:
$response->assertJsonPath($path, $expectedValue);Por exemplo, se a seguinte resposta JSON for retornada pela sua aplicação:
{
"user": {
"name": "Steve Schoger"
}
}Você pode afirmar que a propriedade name do objeto user corresponde a um determinado valor assim:
$response->assertJsonPath('user.name', 'Steve Schoger');Afirme que a resposta não contém o caminho fornecido:
$response->assertJsonMissingPath($path);Por exemplo, se a seguinte resposta JSON for retornada pelo seu aplicativo:
{
"user": {
"name": "Steve Schoger"
}
}Você pode afirmar que não contém a propriedade email do objeto user:
$response->assertJsonMissingPath('user.email');Afirmar que a resposta tem uma estrutura JSON dada:
$response->assertJsonStructure(array $structure);Por exemplo, se a resposta JSON retornada pela sua aplicação contiver os seguintes dados:
{
"user": {
"name": "Steve Schoger"
}
}Você pode afirmar que a estrutura JSON corresponde às suas expectativas como assim:
$response->assertJsonStructure([
'user' => [
'name',
]
]);Às vezes, as respostas JSON retornadas pela sua aplicação podem conter uma matriz de objetos:
{
"user": [
{
"name": "Steve Schoger",
"age": 55,
"location": "Earth"
},
{
"name": "Mary Schoger",
"age": 60,
"location": "Earth"
}
]
}Nesta situação, você pode usar o caractere '*' para afirmar contra a estrutura de todos os objetos no array.
$response->assertJsonStructure([
'user' => [
'*' => [
'name',
'age',
'location'
]
]
]);Afirme que a resposta tem erros de validação JSON para as chaves dadas. Este método deve ser usado quando você está afirmando contra respostas onde os erros de validação são retornados como uma estrutura JSON em vez de serem exibidos na sessão.
$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');::: info NOTA O método assertInvalid genérico pode ser usado para verificar que uma resposta contém erros de validação retornados como JSON ou que os erros foram "flashados" na sessão do armazenamento. :::
Afirma que a resposta tem algum erro de validação do JSON para a chave dada:
$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');Afirmar que a resposta tem um método não permitido (405) HTTP:
$response->assertMethodNotAllowed();Afirme que a resposta tem o código de estado HTTP 301 (movido permanentemente):
$response->assertMovedPermanently();Afirme que a resposta tem o valor URI fornecido no cabeçalho Location:
$response->assertLocation($uri);Afirme que a string dada corresponde ao conteúdo de resposta:
$response->assertContent($value);Afirmar que a resposta tem o dado código de estado http e sem conteúdo:
$response->assertNoContent($status = 204);Afirme que a string fornecida corresponde ao conteúdo da resposta transmitida:
$response->assertStreamedContent($value);Afirme que a resposta tem um código de estado HTTP não encontrado (404):
$response->assertNotFound();Afirmar que a resposta tem um código HTTP 200:
$response->assertOk();Afirme que a resposta tem um código de status HTTP de pagamento obrigatório (402):
$response->assertPaymentRequired();Afirmar que a resposta contém o cookie fornecido não criptografado:
$response->assertPlainCookie($cookieName, $value = null);Afirmar que a resposta é um redirecionamento para o URI fornecido:
$response->assertRedirect($uri = null);Afirme se o resultado redireciona a uma URI que contém a string dada:
$response->assertRedirectContains($string);Afirme que a resposta é um redirecionamento para a rota nomeada:
$response->assertRedirectToRoute($name, $parameters = []);Afirme que a resposta é um redirecionamento para a rota assinada fornecida:
$response->assertRedirectToSignedRoute($name = null, $parameters = []);Afirmar que a resposta tem um tempo limite de requisição (408) HTTP:
$response->assertRequestTimeout();Afirme que a string fornecida esteja contida na resposta. Essa afirmação escapará automaticamente da string fornecida, a menos que você passe um segundo argumento false:
$response->assertSee($value, $escaped = true);Afirme que as strings dadas estão contidas em ordem dentro da resposta. Essa afirmação irá automaticamente escapar das strings dadas, a menos que você passe um segundo argumento false:
$response->assertSeeInOrder(array $values, $escaped = true);Afirma que a string fornecida está contida no texto da resposta. Esta afirmação irá escapar automaticamente a string fornecida, a menos que você passe um segundo argumento de false. O conteúdo da resposta será passado para a função PHP strip_tags antes da afirmação ser feita:
$response->assertSeeText($value, $escaped = true);Afirme que as strings fornecidas estão contidas em ordem dentro do texto de resposta. Esta afirmação irá escapar automaticamente as strings fornecidas, a menos que você passe um segundo argumento de false. O conteúdo da resposta será passado para a função PHP strip_tags antes que a afirmação seja feita:
$response->assertSeeTextInOrder(array $values, $escaped = true);Afirme que a resposta tem um erro de servidor (>= 500, < 600) Código de status HTTP:
$response->assertServerError();Afirme que a resposta tem um "Service Unavailable" (503):
$response->assertServiceUnavailable();Afirme que a sessão contém o dado fornecido:
$response->assertSessionHas($key, $value = null);Se necessário, um closure pode ser fornecido como o segundo argumento para o método assertSessionHas. A asserção passará se o closure retornar true:
$response->assertSessionHas($key, function (User $value) {
return $value->name === 'Taylor Otwell';
});Afirme que a sessão tem um valor fornecido no array de entrada flasheado:
$response->assertSessionHasInput($key, $value = null);Se necessário, um closure pode ser fornecido como o segundo argumento para o método assertSessionHasInput. A afirmação passará se o closure retornar verdadeiro:
use Illuminate\Support\Facades\Crypt;
$response->assertSessionHasInput($key, function (string $value) {
return Crypt::decryptString($value) === 'secret';
});Afirme que a sessão contém um dado array de pares chave/valor.
$response->assertSessionHasAll(array $data);Por exemplo, se a sessão do seu aplicativo contém as chaves 'name' e 'status', você pode afirmar que ambas existem e possuem os valores especificados da seguinte maneira:
$response->assertSessionHasAll([
'name' => 'Taylor Otwell',
'status' => 'active',
]);Afirme que a sessão contém um erro para as $keys fornecidas. Se $keys for uma matriz associativa, afirme que a sessão contém uma mensagem de erro específica (valor) para cada campo (chave). Este método deve ser usado ao testar rotas que exibem erros de validação para a sessão em vez de retorná-los como uma estrutura JSON:
$response->assertSessionHasErrors(
array $keys = [], $format = null, $errorBag = 'default'
);Por exemplo, para afirmar que os campos 'name' e 'email' têm mensagens de erro de validação que foram exibidas na sessão, você pode invocar o método assertSessionHasErrors assim:
$response->assertSessionHasErrors(['name', 'email']);Ou você pode afirmar que um campo dado tem uma mensagem de erro de validação específica:
$response->assertSessionHasErrors([
'name' => 'The given name was invalid.'
]);::: info NOTA O método genérico assertInvalid pode ser usado para afirmar que uma resposta tem erros de validação retornados como JSON ou que os erros foram flashados no armazenamento da sessão. :::
Afirme que a sessão contém um erro para as $keys fornecidas dentro de um error bag específico. Se $keys for uma matriz associativa, afirme que a sessão contém uma mensagem de erro específica (valor) para cada campo (chave), dentro do error bag:
$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);Afirme que a sessão não tem erros de validação:
$response->assertSessionHasNoErrors();Afirmar que a sessão não tem erros de validação para as chaves dadas:
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');::: info NOTA O método mais genérico assertValid pode ser usado para afirmar que uma resposta não tem erros de validação que foram retornados como JSON e que nenhum erro foi enviado ao armazenamento de sessão. :::
Afirme que a sessão não contém a chave fornecida:
$response->assertSessionMissing($key);Afirme que a resposta tem um determinado código de estado HTTP:
$response->assertStatus($code);Afirme que a resposta tem um código de status HTTP bem-sucedido (>= 200 e < 300):
$response->assertSuccessful();Afirme que a resposta tem um código de status HTTP de muitas solicitações (429):
$response->assertTooManyRequests();Afirme que a resposta tem um código de estado HTTP não autorizado (401):
$response->assertUnauthorized();Afirme que a resposta tem um código de estado HTTP não processável (422):
$response->assertUnprocessable();Afirme que a resposta tem um tipo de mídia não suportado (415) Código de status HTTP:
$response->assertUnsupportedMediaType();Afirme que a resposta não tem erros de validação para as chaves fornecidas. Este método pode ser usado para fazer a afirmação contra respostas onde os erros de validação são retornados como uma estrutura JSON ou onde os erros de validação foram exibidos na sessão:
// Afirme que não há erros de validação presentes...
$response->assertValid();
// Afirme que as chaves fornecidas não têm erros de validação...
$response->assertValid(['name', 'email']);Afirme que a resposta tem erros de validação para as chaves fornecidas. Este método pode ser usado para fazer a afirmação contra respostas onde os erros de validação são retornados como uma estrutura JSON ou onde os erros de validação foram exibidos na sessão:
$response->assertInvalid(['name', 'email']);Você também pode afirmar que uma determinada chave tem uma mensagem de erro de validação específica. Ao fazer isso, você pode fornecer a mensagem inteira ou apenas uma pequena parte da mensagem:
$response->assertInvalid([
'name' => 'The name field is required.',
'email' => 'valid email address',
]);Afirme que a resposta contém um determinado pedaço de dados.
$response->assertViewHas($key, $value = null);Passar um closure como segundo argumento para o método assertViewHas permitirá inspecionar e fazer afirmações contra uma peça de dados específicos de exibição.
$response->assertViewHas('user', function (User $user) {
return $user->name === 'Taylor';
});Além disso, os dados de visualização podem ser acessados como variáveis de matriz na resposta, permitindo inspecionar os dados com mais facilidade:
::: code-group
expect($response['name'])->toBe('Taylor');$this->assertEquals('Taylor', $response['name']);:::
Afirme que a resposta visual tem uma determinada lista de dados:
$response->assertViewHasAll(array $data);Este método pode ser usado para afirmar que o conjunto de dados contém apenas os registros correspondentes às chaves dadas:
$response->assertViewHasAll([
'name',
'email',
]);Ou, você pode afirmar que os dados da view estão presentes e têm valores específicos.
$response->assertViewHasAll([
'name' => 'Taylor Otwell',
'email' => 'taylor@example.com,',
]);Afirme que a view dada foi retornada pela rota:
$response->assertViewIs($value);Afirme que a chave de dados fornecida não foi disponibilizada para a visualização retornada na resposta do aplicativo:
$response->assertViewMissing($key);O Laravel também fornece uma variedade de asserções relacionadas à autenticação que você pode utilizar dentro dos testes de recursos do seu aplicativo. Observe que esses métodos são invocados na própria classe de teste e não na instância Illuminate\Testing\TestResponse retornada por métodos como get e post.
Afirmar que o usuário está autenticado:
$this->assertAuthenticated($guard = null);Afirmar que um usuário não está autenticado:
$this->assertGuest($guard = null);Afirme que um usuário específico está autenticado:
$this->assertAuthenticatedAs($user, $guard = null);Laravel fornece duas principais afirmações de validação relacionadas que você pode usar para garantir os dados fornecidos em sua solicitação foram válidos ou inválidos.
Afirme que a resposta não tem erros de validação para as chaves fornecidas. Este método pode ser usado para fazer a afirmação contra respostas onde os erros de validação são retornados como uma estrutura JSON ou onde os erros de validação foram exibidos na sessão:
// Afirme que não há erros de validação presentes...
$response->assertValid();
// Afirme que as chaves fornecidas não têm erros de validação...
$response->assertValid(['name', 'email']);Afirme que a resposta tem erros de validação para as chaves fornecidas. Este método pode ser usado para afirmar contra as respostas onde os erros de validação são retornados como uma estrutura JSON ou onde os erros de validação foram acesos na sessão:
$response->assertInvalid(['name', 'email']);Você também pode afirmar que uma determinada chave tem um erro de validação específico. Ao fazê-lo, você pode fornecer o todo ou apenas uma pequena parte da mensagem:
$response->assertInvalid([
'name' => 'The name field is required.',
'email' => 'valid email address',
]);