Documentación de Laravel 10.x
Aquí encontrarás fragmentos de código de Laravel y consejos útiles sobre desarrollo web.
Laravel proporciona una API muy fluida para realizar solicitudes HTTP a tu aplicación y examinar las respuestas. Por ejemplo, echa un vistazo a la prueba de función definida a continuación:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba. */ public function test_the_application_returns_a_successful_response(): void { $response = $this->get('/'); $response->assertStatus(200); }}
El método get
realiza una solicitud GET
a la aplicación, mientras que el método assertStatus
afirma que la respuesta devuelta debe tener el código de estado HTTP dado. Además de esta afirmación simple, Laravel también contiene una variedad de afirmaciones para inspeccionar los encabezados de respuesta, el contenido, la estructura JSON y más.
Para realizar una solicitud a tu aplicación, puedes invocar los métodos get
, post
, put
, patch
o delete
dentro de tu prueba. Estos métodos no emiten realmente una solicitud HTTP "real" a tu aplicación. En su lugar, la solicitud de red completa se simula internamente.
En lugar de devolver una instancia de Illuminate\Http\Response
, los métodos de solicitud de prueba devuelven una instancia de Illuminate\Testing\TestResponse
, que proporciona una variedad de afirmaciones útiles que te permiten inspeccionar las respuestas de tu aplicación:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba. */ public function test_a_basic_request(): void { $response = $this->get('/'); $response->assertStatus(200); }}
En general, cada una de tus pruebas debería realizar solo una solicitud a tu aplicación. Puede producirse un comportamiento inesperado si se ejecutan múltiples solicitudes dentro de un solo método de prueba.
Nota Para mayor comodidad, el middleware CSRF se desactiva automáticamente al ejecutar pruebas.
Puedes utilizar el método withHeaders
para personalizar los encabezados de la solicitud antes de que se envíe a la aplicación. Este método te permite agregar cualquier encabezado personalizado que desees a la solicitud:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba funcional. */ public function test_interacting_with_headers(): void { $response = $this->withHeaders([ 'X-Header' => 'Value', ])->post('/user', ['name' => 'Sally']); $response->assertStatus(201); }}
Puedes usar los métodos withCookie
o withCookies
para establecer valores de cookies antes de hacer una solicitud. El método withCookie
acepta un nombre y un valor de cookie como sus dos argumentos, mientras que el método withCookies
acepta un array de pares nombre / valor:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ public function test_interacting_with_cookies(): void { $response = $this->withCookie('color', 'blue')->get('/'); $response = $this->withCookies([ 'color' => 'blue', 'name' => 'Taylor', ])->get('/'); }}
Laravel proporciona varios ayudantes para interactuar con la sesión durante las pruebas HTTP. En primer lugar, puedes establecer los datos de la sesión en un array dado usando el método withSession
. Esto es útil para cargar la sesión con datos antes de emitir una solicitud a tu aplicación:
<?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('/'); }}
La sesión de Laravel se utiliza típicamente para mantener el estado del usuario autenticado actualmente. Por lo tanto, el método actingAs
proporciona una forma sencilla de autenticar a un usuario dado como el usuario actual. Por ejemplo, podemos usar un modelo de fábrica para generar y autenticar a un usuario:
<?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('/'); }}
También puedes especificar qué guardia debe usarse para autenticar al usuario dado pasando el nombre de la guardia como segundo argumento al método actingAs
. La guardia que se proporciona al método actingAs
también se convertirá en la guardia predeterminada durante la duración de la prueba:
$this->actingAs($user, 'web')
Después de hacer una solicitud de prueba a tu aplicación, los métodos dump
, dumpHeaders
y dumpSession
se pueden usar para examinar y depurar el contenido de la respuesta:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba. */ public function test_basic_test(): void { $response = $this->get('/'); $response->dumpHeaders(); $response->dumpSession(); $response->dump(); }}
Alternativamente, puedes usar los métodos dd
, ddHeaders
y ddSession
para volcar información sobre la respuesta y luego detener la ejecución:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba. */ public function test_basic_test(): void { $response = $this->get('/'); $response->ddHeaders(); $response->ddSession(); $response->dd(); }}
A veces, es posible que desees probar que tu aplicación está lanzando una excepción específica. Para asegurarte de que la excepción no sea capturada por el manejador de excepciones de Laravel y devuelta como una respuesta HTTP, puedes invocar el método withoutExceptionHandling
antes de hacer tu solicitud:
$response = $this->withoutExceptionHandling()->get('/');
Además, si deseas asegurarte de que tu aplicación no esté utilizando funciones que hayan sido obsoletas por el lenguaje PHP o las bibliotecas que tu aplicación está utilizando, puedes invocar el método withoutDeprecationHandling
antes de hacer tu solicitud. Cuando se deshabilita el manejo de la obsolescencia, las advertencias de obsolescencia se convertirán en excepciones, lo que hará que tu prueba falle:
$response = $this->withoutDeprecationHandling()->get('/');
El método assertThrows
se puede usar para afirmar que el código dentro de un cierre dado lanza una excepción del tipo especificado:
$this->assertThrows( fn () => (new ProcessOrder)->execute(), OrderInvalid::class);
Laravel también proporciona varios ayudantes para probar las API JSON y sus respuestas. Por ejemplo, los métodos json
, getJson
, postJson
, putJson
, patchJson
, deleteJson
y optionsJson
se pueden usar para emitir solicitudes JSON con varios verbos HTTP. También puedes pasar fácilmente datos y encabezados a estos métodos. Para empezar, escribamos una prueba para hacer una solicitud POST
a /api/user
y afirmar que se devolvió el JSON esperado:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba funcional. */ public function test_making_an_api_request(): void { $response = $this->postJson('/api/user', ['name' => 'Sally']); $response ->assertStatus(201) ->assertJson([ 'created' => true, ]); }}
Además, los datos de respuesta JSON se pueden acceder como variables de array en la respuesta, lo que facilita la inspección de los valores individuales devueltos dentro de una respuesta JSON:
$this->assertTrue($response['created']);
Nota El método
assertJson
convierte la respuesta en un array y utilizaPHPUnit::assertArraySubset
para verificar que el array dado existe dentro de la respuesta JSON devuelta por la aplicación. Por lo tanto, si hay otras propiedades en la respuesta JSON, esta prueba seguirá pasando siempre que el fragmento dado esté presente.
Como se mencionó anteriormente, el método assertJson
se puede usar para afirmar que un fragmento de JSON existe dentro de la respuesta JSON. Si deseas verificar que un array dado coincide exactamente con el JSON devuelto por tu aplicación, debes usar el método assertExactJson
:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba funcional. */ public function test_asserting_an_exact_json_match(): void { $response = $this->postJson('/user', ['name' => 'Sally']); $response ->assertStatus(201) ->assertExactJson([ 'created' => true, ]); }}
Si deseas verificar que la respuesta JSON contiene los datos dados en una ruta específica, debes usar el método assertJsonPath
:
<?php namespace Tests\Feature; use Tests\TestCase; class ExampleTest extends TestCase{ /** * Un ejemplo básico de prueba funcional. */ public function test_asserting_a_json_paths_value(): void { $response = $this->postJson('/user', ['name' => 'Sally']); $response ->assertStatus(201) ->assertJsonPath('team.owner.name', 'Darian'); }}
El método assertJsonPath
también acepta un cierre, que se puede usar para determinar dinámicamente si la afirmación debe aprobar:
$response->assertJsonPath('team.owner.name', fn (string $name) => strlen($name) >= 3);
Laravel también ofrece una forma elegante de probar de manera fluida las respuestas JSON de tu aplicación. Para empezar, pasa un cierre al método assertJson
. Este cierre se invocará con una instancia de Illuminate\Testing\Fluent\AssertableJson
que se puede usar para hacer afirmaciones contra el JSON que devolvió tu aplicación. El método where
se puede usar para hacer afirmaciones contra un atributo específico del JSON, mientras que el método missing
se puede usar para afirmar que un atributo específico falta en el JSON:
use Illuminate\Testing\Fluent\AssertableJson; /** * Un ejemplo básico de prueba 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') ->whereNot('status', 'pending') ->missing('password') ->etc() );}
etc
En el ejemplo anterior, es posible que hayas notado que invocamos el método etc
al final de nuestra cadena de afirmaciones. Este método informa a Laravel que puede haber otros atributos presentes en el objeto JSON. Si no se usa el método etc
, la prueba fallará si existen otros atributos en el objeto JSON que no hiciste afirmaciones contra ellos.
La intención detrás de este comportamiento es protegerte de exponer inadvertidamente información sensible en tus respuestas JSON obligándote a hacer explícitas afirmaciones contra el atributo o permitir explícitamente atributos adicionales mediante el método etc
.
Sin embargo, debes tener en cuenta que no incluir el método etc
en tu cadena de afirmaciones no garantiza que no se estén agregando atributos adicionales a los arrays que están anidados dentro de tu objeto JSON. El método etc
solo asegura que no existan atributos adicionales en el nivel de anidamiento en el que se invoca el método etc
.
Para afirmar que un atributo está presente o ausente, puedes usar los métodos has
y missing
:
$response->assertJson(fn (AssertableJson $json) => $json->has('data') ->missing('message'));
Además, los métodos hasAll
y missingAll
permiten afirmar la presencia o ausencia de múltiples atributos simultáneamente:
$response->assertJson(fn (AssertableJson $json) => $json->hasAll(['status', 'data']) ->missingAll(['message', 'code']));
Puedes usar el método hasAny
para determinar si al menos uno de una lista dada de atributos está presente:
$response->assertJson(fn (AssertableJson $json) => $json->has('status') ->hasAny('data', 'message', 'code'));
A menudo, tu ruta devolverá una respuesta JSON que contiene varios elementos, como varios usuarios:
Route::get('/users', function () { return User::all();});
En estas situaciones, podemos usar el método has
del objeto JSON fluido para hacer afirmaciones sobre los usuarios incluidos en la respuesta. Por ejemplo, afirmemos que la respuesta JSON contiene tres usuarios. Luego, haremos algunas afirmaciones sobre el primer usuario en la colección usando el método first
. El método first
acepta un cierre que recibe otra cadena JSON asertable que podemos usar para hacer afirmaciones sobre el primer objeto en la colección JSON:
$response ->assertJson(fn (AssertableJson $json) => $json->has(3) ->first(fn (AssertableJson $json) => $json->where('id', 1) ->where('name', 'Victoria Faith') ->missing('password') ->etc() ) );
A veces, las rutas de tu aplicación devolverán colecciones JSON que se asignan a claves con nombre:
Route::get('/users', function () { return [ 'meta' => [...], 'users' => User::all(), ];})
Al probar estas rutas, puedes usar el método has
para afirmar contra la cantidad de elementos en la colección. Además, puedes usar el método has
para delimitar una cadena de afirmaciones:
$response ->assertJson(fn (AssertableJson $json) => $json->has('meta') ->has('users', 3) ->has('users.0', fn (AssertableJson $json) => $json->where('id', 1) ->where('name', 'Victoria Faith') ->missing('password') ->etc() ) );
Sin embargo, en lugar de hacer dos llamadas separadas al método has
para afirmar contra la colección users
, puedes hacer una sola llamada que proporcione un cierre como tercer parámetro. Al hacerlo, el cierre se invocará automáticamente y se delimitará al primer elemento de la colección:
$response ->assertJson(fn (AssertableJson $json) => $json->has('meta') ->has('users', 3, fn (AssertableJson $json) => $json->where('id', 1) ->where('name', 'Victoria Faith') ->missing('password') ->etc() ) );
Puede que solo desees afirmar que las propiedades en la respuesta JSON son de un cierto tipo. La clase Illuminate\Testing\Fluent\AssertableJson
proporciona los métodos whereType
y whereAllType
para hacer precisamente eso:
$response->assertJson(fn (AssertableJson $json) => $json->whereType('id', 'integer') ->whereAllType([ 'users.0.name' => 'string', 'meta' => 'array' ]));
Puedes especificar varios tipos usando el carácter |
o pasando un array de tipos como segundo parámetro al método whereType
. La afirmación será exitosa si el valor de la respuesta es alguno de los tipos enumerados:
$response->assertJson(fn (AssertableJson $json) => $json->whereType('name', 'string|null') ->whereType('id', ['string', 'integer']));
Los métodos whereType
y whereAllType
reconocen los siguientes tipos: string
, integer
, double
, boolean
, array
y null
.
La clase Illuminate\Http\UploadedFile
proporciona un método fake
que se puede utilizar para generar archivos o imágenes ficticias para las pruebas. Esto, combinado con el método fake
de la fachada Storage
, simplifica en gran medida las pruebas de la carga de archivos. Por ejemplo, puedes combinar estas dos características para probar fácilmente un formulario de carga de avatar:
<?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()); }}
Si deseas afirmar que un archivo dado no existe, puedes usar el método assertMissing
proporcionado por la fachada Storage
:
Storage::fake('avatars'); // ... Storage::disk('avatars')->assertMissing('missing.jpg');
Al crear archivos usando el método fake
proporcionado por la clase UploadedFile
, puedes especificar el ancho, alto y tamaño de la imagen (en kilobytes) para probar mejor las reglas de validación de tu aplicación:
UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);
Además de crear imágenes, puedes crear archivos de cualquier otro tipo usando el método create
:
UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);
Si es necesario, puedes pasar un argumento $mimeType
al método para definir explícitamente el tipo MIME que debería ser devuelto por el archivo:
UploadedFile::fake()->create( 'document.pdf', $sizeInKilobytes, 'application/pdf');
Laravel también te permite renderizar una vista sin hacer una solicitud HTTP simulada a la aplicación. Para lograr esto, puedes llamar al método view
dentro de tu prueba. El método view
acepta el nombre de la vista y un array opcional de datos. El método devuelve una instancia de Illuminate\Testing\TestView
, que ofrece varios métodos para hacer afirmaciones convenientes sobre el contenido de la vista:
<?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'); }}
La clase TestView
proporciona los siguientes métodos de afirmación: assertSee
, assertSeeInOrder
, assertSeeText
, assertSeeTextInOrder
, assertDontSee
y assertDontSeeText
.
Si es necesario, puedes obtener el contenido de la vista sin formato y renderizado mediante la conversión de la instancia TestView
a una cadena:
$contents = (string) $this->view('welcome');
Algunas vistas pueden depender de errores compartidos en la bolsa de errores global proporcionada por Laravel. Para hidratar la bolsa de errores con mensajes de error, puedes usar el método withViewErrors
:
$view = $this->withViewErrors([ 'name' => ['Please provide a valid name.']])->view('form'); $view->assertSee('Please provide a valid name.');
Si es necesario, puedes usar el método blade
para evaluar y renderizar una cadena Blade sin procesar. Al igual que el método view
, el método blade
devuelve una instancia de Illuminate\Testing\TestView
:
$view = $this->blade( '<x-component :name="$name" />', ['name' => 'Taylor']); $view->assertSee('Taylor');
Puedes usar el método component
para evaluar y renderizar un componente Blade. El método component
devuelve una instancia de Illuminate\Testing\TestComponent
:
$view = $this->component(Profile::class, ['name' => 'Taylor']); $view->assertSee('Taylor');
La clase Illuminate\Testing\TestResponse
de Laravel proporciona una variedad de métodos de afirmación personalizados que puedes utilizar al probar tu aplicación. Estas afirmaciones se pueden acceder en la respuesta que devuelve los métodos de prueba json
, get
, post
, put
y 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
Asegura que la respuesta tenga un código de estado HTTP de solicitud incorrecta (400):
$response->assertBadRequest();
Asegura que la respuesta tenga un código de estado HTTP aceptado (202):
$response->assertAccepted();
Asegura que la respuesta tenga un código de estado HTTP de conflicto (409):
$response->assertConflict();
Asegura que la respuesta contenga la cookie especificada:
$response->assertCookie($cookieName, $value = null);
Asegura que la respuesta contenga la cookie especificada y que esté caducada:
$response->assertCookieExpired($cookieName);
Asegura que la respuesta contenga la cookie especificada y que no esté caducada:
$response->assertCookieNotExpired($cookieName);
Asegura que la respuesta no contenga la cookie especificada:
$response->assertCookieMissing($cookieName);
Asegura que la respuesta tenga un código de estado HTTP de 201:
$response->assertCreated();
Asegura que la cadena especificada no esté contenida en la respuesta devuelta por la aplicación. Esta afirmación escapará automáticamente la cadena especificada a menos que pases un segundo argumento de false
:
$response->assertDontSee($value, $escaped = true);
Asegura que la cadena especificada no esté contenida en el texto de la respuesta. Esta afirmación escapará automáticamente la cadena especificada a menos que pases un segundo argumento de false
. Este método pasará el contenido de la respuesta a la función strip_tags
de PHP antes de hacer la afirmación:
$response->assertDontSeeText($value, $escaped = true);
Asegura que la respuesta es una "descarga". Normalmente, esto significa que la ruta invocada que devolvió la respuesta devolvió una respuesta Response::download
, BinaryFileResponse
o Storage::download
:
$response->assertDownload();
Si lo deseas, puedes afirmar que el archivo descargable recibió un nombre de archivo dado:
$response->assertDownload('image.jpg');
Asegura que la respuesta contenga una coincidencia exacta con los datos JSON proporcionados:
$response->assertExactJson(array $data);
Asegura que la respuesta tenga un código de estado HTTP de prohibido (403):
$response->assertForbidden();
Asegura que la respuesta tenga un código de estado HTTP de encontrado (302):
$response->assertFound();
Asegura que la respuesta tenga un código de estado HTTP de desaparecido (410):
$response->assertGone();
Asegura que el encabezado dado y su valor estén presentes en la respuesta:
$response->assertHeader($headerName, $value = null);
Asegura que el encabezado dado no esté presente en la respuesta:
$response->assertHeaderMissing($headerName);
Asegura que la respuesta tenga un código de estado HTTP de "Error interno del servidor" (500):
$response->assertInternalServerError();
Asegura que la respuesta contenga los datos JSON proporcionados:
$response->assertJson(array $data, $strict = false);
El método assertJson
convierte la respuesta en un array y utiliza PHPUnit::assertArraySubset
para verificar que el array dado existe dentro de la respuesta JSON devuelta por la aplicación. Por lo tanto, si hay otras propiedades en la respuesta JSON, esta prueba seguirá pasando siempre que el fragmento dado esté presente.
Asegura que el JSON de la respuesta tenga un array con el número esperado de elementos en la clave dada:
$response->assertJsonCount($count, $key = null);
Asegura que la respuesta contenga los datos JSON proporcionados en cualquier lugar de la respuesta:
Route::get('/users', function () { return [ 'users' => [ [ 'name' => 'Taylor Otwell', ], ], ];}); $response->assertJsonFragment(['name' => 'Taylor Otwell']);
Asegura que el JSON de la respuesta sea un array:
$response->assertJsonIsArray();
Asegura que el JSON de la respuesta sea un objeto:
$response->assertJsonIsObject();
Asegura que la respuesta no contenga los datos JSON proporcionados:
$response->assertJsonMissing(array $data);
Asegura que la respuesta no contenga los datos JSON exactos:
$response->assertJsonMissingExact(array $data);
Asegura que la respuesta no tenga errores de validación JSON para las claves dadas:
$response->assertJsonMissingValidationErrors($keys);
Nota El método más genérico assertValid se puede usar para afirmar que una respuesta no tiene errores de validación devueltos como JSON y que no se han almacenado errores en la sesión.
Asegura que la respuesta contenga los datos en la ruta especificada:
$response->assertJsonPath($path, $expectedValue);
Por ejemplo, si la siguiente respuesta JSON es devuelta por tu aplicación:
{ "user": { "name": "Steve Schoger" }}
Puedes asegurar que la propiedad name
del objeto user
coincida con un valor dado de la siguiente manera:
$response->assertJsonPath('user.name', 'Steve Schoger');
Asegura que la respuesta no contenga la ruta dada:
$response->assertJsonMissingPath($path);
Por ejemplo, si la siguiente respuesta JSON es devuelta por tu aplicación:
{ "user": { "name": "Steve Schoger" }}
Puedes asegurar que no contenga la propiedad email
del objeto user
:
$response->assertJsonMissingPath('user.email');
Asegura que la respuesta tenga una estructura JSON dada:
$response->assertJsonStructure(array $structure);
Por ejemplo, si la respuesta JSON devuelta por tu aplicación contiene los siguientes datos:
{ "user": { "name": "Steve Schoger" }}
Puedes asegurar que la estructura JSON coincida con tus expectativas de la siguiente manera:
$response->assertJsonStructure([ 'user' => [ 'name', ]]);
A veces, las respuestas JSON devueltas por tu aplicación pueden contener arrays de objetos:
{ "user": [ { "name": "Steve Schoger", "age": 55, "location": "Earth" }, { "name": "Mary Schoger", "age": 60, "location": "Earth" } ]}
En esta situación, puedes usar el carácter *
para asegurar la estructura de todos los objetos en el array:
$response->assertJsonStructure([ 'user' => [ '*' => [ 'name', 'age', 'location' ] ]]);
Asegura que la respuesta tenga los errores de validación JSON para las claves dadas. Este método debería usarse al hacer afirmaciones contra respuestas donde los errores de validación se devuelven como una estructura JSON en lugar de ser flasheados a la sesión:
$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');
Nota El método más genérico assertInvalid se puede usar para afirmar que una respuesta tiene errores de validación devueltos como JSON o que se han almacenado errores en la sesión.
Asegura que la respuesta tiene errores de validación JSON para la clave dada:
$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');
Asegura que la respuesta tiene un código de estado HTTP de método no permitido (405):
$response->assertMethodNotAllowed();
Asegura que la respuesta tiene un código de estado HTTP de movido permanentemente (301):
$response->assertMovedPermanently();
Asegura que la respuesta tiene el valor de URI dado en el encabezado Location
:
$response->assertLocation($uri);
Asegura que la cadena dada coincide con el contenido de la respuesta:
$response->assertContent($value);
Asegura que la respuesta tiene el código de estado HTTP dado y sin contenido:
$response->assertNoContent($status = 204);
Asegura que la cadena dada coincide con el contenido transmitido de la respuesta:
$response->assertStreamedContent($value);
Asegura que la respuesta tiene un código de estado HTTP de no encontrado (404):
$response->assertNotFound();
Asegura que la respuesta tiene un código de estado HTTP 200:
$response->assertOk();
Asegura que la respuesta tiene un código de estado HTTP de pago requerido (402):
$response->assertPaymentRequired();
Asegura que la respuesta contiene la cookie no cifrada dada:
$response->assertPlainCookie($cookieName, $value = null);
Asegura que la respuesta es una redirección a la URI dada:
$response->assertRedirect($uri = null);
Asegura si la respuesta se redirige a una URI que contiene la cadena dada:
$response->assertRedirectContains($string);
Asegura que la respuesta es una redirección a la ruta con nombre dada:
$response->assertRedirectToRoute($name, $parameters = []);
Asegura que la respuesta es una redirección a la ruta firmada dada:
$response->assertRedirectToSignedRoute($name = null, $parameters = []);
Asegura que la respuesta tiene un código de estado HTTP de tiempo de espera de solicitud (408):
$response->assertRequestTimeout();
Asegura que la cadena dada está contenida en la respuesta. Esta afirmación escapará automáticamente la cadena dada a menos que pases un segundo argumento de false
:
$response->assertSee($value, $escaped = true);
Asegura que las cadenas dadas están contenidas en orden en la respuesta. Esta afirmación escapará automáticamente las cadenas dadas a menos que pases un segundo argumento de false
:
$response->assertSeeInOrder(array $values, $escaped = true);
Asegura que la cadena dada está contenida en el texto de la respuesta. Esta afirmación escapará automáticamente la cadena dada a menos que pases un segundo argumento de false
. El contenido de la respuesta se pasará a la función strip_tags
de PHP antes de hacer la afirmación:
$response->assertSeeText($value, $escaped = true);
Asegura que las cadenas dadas están contenidas en orden en el texto de la respuesta. Esta afirmación escapará automáticamente las cadenas dadas a menos que pases un segundo argumento de false
. El contenido de la respuesta se pasará a la función strip_tags
de PHP antes de hacer la afirmación:
$response->assertSeeTextInOrder(array $values, $escaped = true);
Asegura que la respuesta tiene un código de estado HTTP de error de servidor (>= 500, < 600):
$response->assertServerError();
Asegura que la respuesta tiene un código de estado HTTP de "Servicio no disponible" (503):
$response->assertServiceUnavailable();
Asegura que la sesión contiene la pieza de datos dada:
$response->assertSessionHas($key, $value = null);
Si es necesario, se puede proporcionar un cierre como segundo argumento al método assertSessionHas
. La afirmación pasará si el cierre devuelve true
:
$response->assertSessionHas($key, function (User $value) { return $value->name === 'Taylor Otwell';});
Asegura que la sesión tiene un valor dado en el array de entrada parpadeado:
$response->assertSessionHasInput($key, $value = null);
Si es necesario, se puede proporcionar un cierre como segundo argumento al método assertSessionHasInput
. La afirmación pasará si el cierre devuelve true
:
use Illuminate\Support\Facades\Crypt; $response->assertSessionHasInput($key, function (string $value) { return Crypt::decryptString($value) === 'secret';});
Asegura que la sesión contiene un array dado de pares clave / valor:
$response->assertSessionHasAll(array $data);
Por ejemplo, si la sesión de tu aplicación contiene las claves nombre
y estado
, puedes afirmar que ambas existen y tienen los valores especificados de la siguiente manera:
$response->assertSessionHasAll([ 'name' => 'Taylor Otwell', 'status' => 'active',]);
Asegura que la sesión contiene un error para las claves dadas. Si $keys
es un array asociativo, asegura que la sesión contiene un mensaje de error específico (valor) para cada campo (clave). Este método debe usarse al probar rutas que almacenan errores de validación en la sesión en lugar de devolverlos como una estructura JSON:
$response->assertSessionHasErrors( array $keys = [], $format = null, $errorBag = 'default');
Por ejemplo, para afirmar que los campos nombre
y email
tienen mensajes de error de validación que se almacenaron en la sesión, puedes invocar el método assertSessionHasErrors
de la siguiente manera:
$response->assertSessionHasErrors(['name', 'email']);
O puedes afirmar que un campo dado tiene un mensaje de error de validación específico:
$response->assertSessionHasErrors([ 'name' => 'The given name was invalid.']);
Nota El método más genérico assertInvalid se puede usar para afirmar que una respuesta tiene errores de validación devueltos como JSON o que se han almacenado errores en la sesión.
Asegura que la sesión contiene un error para las claves dadas dentro de una bolsa de errores específica. Si $keys
es un array asociativo, asegura que la sesión contiene un mensaje de error específico (valor) para cada campo (clave) dentro de la bolsa de errores:
$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);
Asegura que la sesión no tiene errores de validación:
$response->assertSessionHasNoErrors();
Asegura que la sesión no tiene errores de validación para las claves dadas:
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');
Nota El método más genérico assertValid se puede usar para afirmar que una respuesta no tiene errores de validación devueltos como JSON y que no se han almacenado errores en la sesión.
Asegura que la sesión no contiene la clave dada:
$response->assertSessionMissing($key);
Asegura que la respuesta tiene un código de estado HTTP dado:
$response->assertStatus($code);
Asegura que la respuesta tiene un código de estado HTTP exitoso (>= 200 y < 300):
$response->assertSuccessful();
Asegura que la respuesta tiene un código de estado HTTP de demasiadas solicitudes (429):
$response->assertTooManyRequests();
Asegura que la respuesta tiene un código de estado HTTP no autorizado (401):
$response->assertUnauthorized();
Asegura que la respuesta tiene un código de estado HTTP de entidad no procesable (422):
$response->assertUnprocessable();
Asegura que la respuesta tiene un código de estado HTTP de tipo de medio no admitido (415):
$response->assertUnsupportedMediaType();
Asegura que la respuesta no tiene errores de validación para las claves dadas. Este método se puede usar para afirmar contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación se han almacenado en la sesión:
// Asegura que no haya errores de validación...$response->assertValid(); // Asegura que las claves dadas no tengan errores de validación...$response->assertValid(['name', 'email']);
Asegura que la respuesta tiene errores de validación para las claves dadas. Este método se puede usar para afirmar contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación se han almacenado en la sesión:
$response->assertInvalid(['name', 'email']);
También puedes afirmar que una clave dada tiene un mensaje de error de validación específico. Al hacerlo, puedes proporcionar el mensaje completo o solo una pequeña parte del mensaje:
$response->assertInvalid([ 'name' => 'The name field is required.', 'email' => 'valid email address',]);
Asegura que la vista de respuesta contiene una pieza de datos dada:
$response->assertViewHas($key, $value = null);
Pasando un cierre como segundo argumento al método assertViewHas
te permitirá inspeccionar y hacer afirmaciones contra una parte específica de los datos de la vista:
$response->assertViewHas('user', function (User $user) { return $user->name === 'Taylor';});
Además, los datos de la vista se pueden acceder como variables de array en la respuesta, lo que te permite inspeccionarlos de manera conveniente:
$this->assertEquals('Taylor', $response['name']);
Asegura que la vista de respuesta tiene una lista dada de datos:
$response->assertViewHasAll(array $data);
Este método se puede usar para afirmar que la vista simplemente contiene datos que coinciden con las claves dadas:
$response->assertViewHasAll([ 'name', 'email',]);
O puedes afirmar que los datos de la vista están presentes y tienen valores específicos:
$response->assertViewHasAll([ 'name' => 'Taylor Otwell',]);
Asegura que la vista dada fue devuelta por la ruta:
$response->assertViewIs($value);
Asegura que la clave de datos dada no estuvo disponible para la vista devuelta en la respuesta de la aplicación:
$response->assertViewMissing($key);
Laravel también proporciona una variedad de afirmaciones relacionadas con la autenticación que puedes utilizar en las pruebas de funciones de tu aplicación. Ten en cuenta que estos métodos se invocan en la clase de prueba en sí y no en la instancia de Illuminate\Testing\TestResponse
devuelta por métodos como get
y post
.
Asegura que un usuario está autenticado:
$this->assertAuthenticated($guard = null);
Asegura que un usuario no está autenticado:
$this->assertGuest($guard = null);
Asegura que un usuario específico está autenticado:
$this->assertAuthenticatedAs($user, $guard = null);
Laravel proporciona dos afirmaciones principales relacionadas con la validación que puedes usar para asegurarte de que los datos proporcionados en tu solicitud fueron válidos o no válidos.
Asegura que la respuesta no tiene errores de validación para las claves dadas. Este método se puede usar para afirmar contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación se han almacenado en la sesión:
// Asegura que no haya errores de validación...$response->assertValid(); // Asegura que las claves dadas no tengan errores de validación...$response->assertValid(['name', 'email']);
Asegura que la respuesta tiene errores de validación para las claves dadas. Este método se puede usar para afirmar contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación se han almacenado en la sesión:
$response->assertInvalid(['name', 'email']);
También puedes afirmar que una clave dada tiene un mensaje de error de validación específico. Al hacerlo, puedes proporcionar el mensaje completo o solo una pequeña parte del mensaje:
$response->assertInvalid([ 'name' => 'The name field is required.', 'email' => 'valid email address',]);