Teste HTTP
Introdução
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:
<?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.
Fazendo Solicitações
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:
<?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.
Nota
Para conveniência, o middleware CSRF é desativado automaticamente quando os testes são executados.
Personalizando cabeçalhos de solicitação
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:
<?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);
}
}
Cookies
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('/');
//
}
}
:::
Sessão / Autenticação
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.
<?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:
<?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')
Respostas para depuração de erros
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:
<?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.
<?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();
}
}
Tratamento de Exceções
À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:
<?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
);
Testando APIs JSON
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:
<?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.
expect($response['created'])->toBeTrue();
$this->assertTrue($response['created']);
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.
Afirmando Combinações Exatas do JSON
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
:
<?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,
]);
}
}
Afirmando caminhos JSON
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
:
<?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);
Testes Fluente de JSON
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:
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()
);
}
Compreendendo o Método 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.
Afirmando presença/ausência de atributos
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')
);
Afirmando contra coleções JSON
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()
)
);
Escopo de asserções de coleção JSON
À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()
)
);
Assertando tipos JSON
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
.
Teste de upload de arquivos
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:
<?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');
Personalização de Arquivos Falsos
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'
);
Testando Views
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:
<?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');
Compartilhando Erros
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.');
Renderização de blades e componentes
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');
Afirmações disponíveis
Afirmações para Resposta
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
:
assertAcceptedassertBadRequestassertConflictassertCookieassertCookieExpiredassertCookieNotExpiredassertCookieMissingassertCreatedassertDontSeeassertDontSeeTextassertDownloadassertExactJsonassertForbiddenassertFoundassertGoneassertHeaderassertHeaderMissingassertInternalServerErrorassertJsonassertJsonCountassertJsonFragmentassertJsonIsArrayassertJsonIsObjectassertJsonMissingassertJsonMissingExactassertJsonMissingValidationErrorsassertJsonPathassertJsonMissingPathassertJsonStructureassertJsonValidationErrorsassertJsonValidationErrorForassertLocationassertMethodNotAllowedassertMovedPermanentlyassertContentassertNoContentassertStreamedContentassertNotFoundassertOkassertPaymentRequiredassertPlainCookieassertRedirectassertRedirectContainsassertRedirectToRouteassertRedirectToSignedRouteassertRequestTimeoutassertSeeassertSeeInOrderassertSeeTextassertSeeTextInOrderassertServerErrorassertServiceUnavailableassertSessionHasassertSessionHasInputassertSessionHasAllassertSessionHasErrorsassertSessionHasErrorsInassertSessionHasNoErrorsassertSessionDoesntHaveErrorsassertSessionMissingassertStatusassertSuccessfulassertTooManyRequestsassertUnauthorizedassertUnprocessableassertUnsupportedMediaTypeassertValidassertInvalidassertViewHasassertViewHasAllassertViewIsassertViewMissing
assertBadRequest
Afirmar que a requisição é inválida (400) no código de estado HTTP:
$response->assertBadRequest();
assertAccepted
Afirmar que a resposta tem um código de estado HTTP aceito (202):
$response->assertAccepted();
assertConflict
Afirme que a resposta tem um conflito (409) código de estado HTTP:
$response->assertConflict();
assertCookie
Afirmar que a resposta contém o cookie fornecido.
$response->assertCookie($cookieName, $value = null);
assertCookieExpired
Afirme que a resposta contém o cookie dado e está expirado:
$response->assertCookieExpired($cookieName);
assertCookieNotExpired
Afirme que a resposta contém o cookie fornecido e não está expirado:
$response->assertCookieNotExpired($cookieName);
assertCookieMissing
Afirme que a resposta não contém o cookie fornecido:
$response->assertCookieMissing($cookieName);
assertCreated
Afirme que a resposta tem o código de estado HTTP 201.
$response->assertCreated();
assertDontSee
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);
assertDontSeeText
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);
assertDownload
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');
assertExactJson
Afirme que a resposta contém uma correspondência exata dos dados JSON fornecidos:
$response->assertExactJson(array $data);
assertForbidden
Afirme que o response tem um status de http 403:
$response->assertForbidden();
assertFound
Afirmar que a resposta tem um código de estado HTTP (302):
$response->assertFound();
assertGone
Afirmar que a resposta tem um (410) código de estado HTTP:
$response->assertGone();
assertHeader
Afirmar que o cabeçalho e valor dados estão presentes na resposta.
$response->assertHeader($headerName, $value = null);
assertHeaderMissing
Afirmar que o cabeçalho fornecido não está presente na resposta:
$response->assertHeaderMissing($headerName);
assertInternalServerError
Afirmar que a resposta tem o código de estado http "Internal Server Error" (500):
$response->assertInternalServerError();
assertJson
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.
assertJsonCount
Afirme que a resposta JSON tem uma matriz com o número esperado de itens na chave dada:
$response->assertJsonCount($count, $key = null);
assertJsonFragment
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']);
assertJsonIsArray
Afirmar que a resposta JSON é um array:
$response->assertJsonIsArray();
assertJsonIsObject
Afirmar que a resposta JSON é um objeto:
$response->assertJsonIsObject();
assertJsonMissing
Afirme que a resposta não contém os dados JSON fornecidos:
$response->assertJsonMissing(array $data);
assertJsonMissingExact
Afirme que a resposta não contém os dados JSON exatos:
$response->assertJsonMissingExact(array $data);
assertJsonMissingValidationErrors
Afirme que a resposta não possui erros de validação JSON para as chaves especificadas:
$response->assertJsonMissingValidationErrors($keys);
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.
assertJsonPath
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');
assertJsonMissingPath
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');
assertJsonStructure
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'
]
]
]);
assertJsonValidationErrors
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');
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.
assertJsonValidationErrorFor
Afirma que a resposta tem algum erro de validação do JSON para a chave dada:
$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');
assertMethodNotAllowed
Afirmar que a resposta tem um método não permitido (405) HTTP:
$response->assertMethodNotAllowed();
assertMovedPermanently
Afirme que a resposta tem o código de estado HTTP 301 (movido permanentemente):
$response->assertMovedPermanently();
assertLocation
Afirme que a resposta tem o valor URI fornecido no cabeçalho Location
:
$response->assertLocation($uri);
assertContent
Afirme que a string dada corresponde ao conteúdo de resposta:
$response->assertContent($value);
assertNoContent
Afirmar que a resposta tem o dado código de estado http e sem conteúdo:
$response->assertNoContent($status = 204);
assertStreamedContent
Afirme que a string fornecida corresponde ao conteúdo da resposta transmitida:
$response->assertStreamedContent($value);
assertNotFound
Afirme que a resposta tem um código de estado HTTP não encontrado (404):
$response->assertNotFound();
assertOk
Afirmar que a resposta tem um código HTTP 200:
$response->assertOk();
assertPaymentRequired
Afirme que a resposta tem um código de status HTTP de pagamento obrigatório (402):
$response->assertPaymentRequired();
assertPlainCookie
Afirmar que a resposta contém o cookie fornecido não criptografado:
$response->assertPlainCookie($cookieName, $value = null);
assertRedirect
Afirmar que a resposta é um redirecionamento para o URI fornecido:
$response->assertRedirect($uri = null);
assertRedirectContains
Afirme se o resultado redireciona a uma URI que contém a string dada:
$response->assertRedirectContains($string);
assertRedirectToRoute
Afirme que a resposta é um redirecionamento para a rota nomeada:
$response->assertRedirectToRoute($name, $parameters = []);
assertRedirectToSignedRoute
Afirme que a resposta é um redirecionamento para a rota assinada fornecida:
$response->assertRedirectToSignedRoute($name = null, $parameters = []);
assertRequestTimeout
Afirmar que a resposta tem um tempo limite de requisição (408) HTTP:
$response->assertRequestTimeout();
assertSee
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);
assertSeeInOrder
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);
assertSeeText
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);
assertSeeTextInOrder
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);
assertServerError
Afirme que a resposta tem um erro de servidor (>= 500, < 600) Código de status HTTP:
$response->assertServerError();
assertServiceUnavailable
Afirme que a resposta tem um "Service Unavailable" (503):
$response->assertServiceUnavailable();
assertSessionHas
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';
});
assertSessionHasInput
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';
});
assertSessionHasAll
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',
]);
assertSessionHasErrors
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.'
]);
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.
assertSessionHasErrorsIn
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);
assertSessionHasNoErrors
Afirme que a sessão não tem erros de validação:
$response->assertSessionHasNoErrors();
assertSessionDoesntHaveErrors
Afirmar que a sessão não tem erros de validação para as chaves dadas:
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');
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.
assertSessionMissing
Afirme que a sessão não contém a chave fornecida:
$response->assertSessionMissing($key);
assertStatus
Afirme que a resposta tem um determinado código de estado HTTP:
$response->assertStatus($code);
assertSuccessful
Afirme que a resposta tem um código de status HTTP bem-sucedido (>= 200 e < 300):
$response->assertSuccessful();
assertTooManyRequests
Afirme que a resposta tem um código de status HTTP de muitas solicitações (429):
$response->assertTooManyRequests();
assertUnauthorized
Afirme que a resposta tem um código de estado HTTP não autorizado (401):
$response->assertUnauthorized();
assertUnprocessable
Afirme que a resposta tem um código de estado HTTP não processável (422):
$response->assertUnprocessable();
assertUnsupportedMediaType
Afirme que a resposta tem um tipo de mídia não suportado (415) Código de status HTTP:
$response->assertUnsupportedMediaType();
assertValid
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']);
assertInvalid
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',
]);
assertViewHas
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:
expect($response['name'])->toBe('Taylor');
$this->assertEquals('Taylor', $response['name']);
assertViewHasAll
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,',
]);
assertViewIs
Afirme que a view dada foi retornada pela rota:
$response->assertViewIs($value);
assertViewMissing
Afirme que a chave de dados fornecida não foi disponibilizada para a visualização retornada na resposta do aplicativo:
$response->assertViewMissing($key);
Afirmações de Autenticação
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
.
assertAuthenticated
Afirmar que o usuário está autenticado:
$this->assertAuthenticated($guard = null);
assertGuest
Afirmar que um usuário não está autenticado:
$this->assertGuest($guard = null);
assertAuthenticatedAs
Afirme que um usuário específico está autenticado:
$this->assertAuthenticatedAs($user, $guard = null);
Afirmações para Validação
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.
assertValid
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']);
assertInvalid
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',
]);