Pruebas HTTP en Laravel 10.x: Escritura y Comprobación de Pruebas

Introducción
Realizar solicitudes
Pruebas de APIs JSON
- Pruebas fluidas de JSON
Pruebas de carga de archivos
Pruebas de vistas
- Renderizado de Blade y componentes
Asertos disponibles

Introducción

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.

Realizar solicitudes

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.

Personalizar encabezados de solicitud

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);
    }
}

Cookies

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('/');
    }
}

Sesión / Autenticación

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')

Depuración de respuestas

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();
    }
}

Manejo de excepciones

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
);

Pruebas de APIs JSON

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 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.

Asegurar coincidencias exactas de JSON

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,
            ]);
    }
}

Asegurar en rutas JSON

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);

Pruebas fluidas de JSON

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')
                 ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                 ->whereNot('status', 'pending')
                 ->missing('password')
                 ->etc()
        );
}

Entendiendo el método `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.

Asegurar presencia / ausencia de atributos

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')
);

Asegurar contra colecciones JSON

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')
                     ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                     ->missing('password')
                     ->etc()
             )
    );

Limitar asertos de colecciones JSON

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')
                     ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                     ->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')
                     ->where('email', fn (string $email) => str($email)->is('[email protected]'))
                     ->missing('password')
                     ->etc()
             )
    );

Asegurar tipos JSON

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.

Pruebas de carga de archivos

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');

Personalización de archivos falsos

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'
);

Pruebas de vistas

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');

Compartir errores

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.');

Renderizado de Blade y componentes

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');

Asertos disponibles

Asertos de respuesta

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

assertBadRequest

Asegura que la respuesta tenga un código de estado HTTP de solicitud incorrecta (400):

$response->assertBadRequest();

assertAccepted

Asegura que la respuesta tenga un código de estado HTTP aceptado (202):

$response->assertAccepted();

assertConflict

Asegura que la respuesta tenga un código de estado HTTP de conflicto (409):

$response->assertConflict();

assertCookie

Asegura que la respuesta contenga la cookie especificada:

$response->assertCookie($cookieName, $value = null);

assertCookieExpired

Asegura que la respuesta contenga la cookie especificada y que esté caducada:

$response->assertCookieExpired($cookieName);

assertCookieNotExpired

Asegura que la respuesta contenga la cookie especificada y que no esté caducada:

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

Asegura que la respuesta no contenga la cookie especificada:

$response->assertCookieMissing($cookieName);

assertCreated

Asegura que la respuesta tenga un código de estado HTTP de 201:

$response->assertCreated();

assertDontSee

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);

assertDontSeeText

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);

assertDownload

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');

assertExactJson

Asegura que la respuesta contenga una coincidencia exacta con los datos JSON proporcionados:

$response->assertExactJson(array $data);

assertForbidden

Asegura que la respuesta tenga un código de estado HTTP de prohibido (403):

$response->assertForbidden();

assertFound

Asegura que la respuesta tenga un código de estado HTTP de encontrado (302):

$response->assertFound();

assertGone

Asegura que la respuesta tenga un código de estado HTTP de desaparecido (410):

$response->assertGone();

assertHeader

Asegura que el encabezado dado y su valor estén presentes en la respuesta:

$response->assertHeader($headerName, $value = null);

assertHeaderMissing

Asegura que el encabezado dado no esté presente en la respuesta:

$response->assertHeaderMissing($headerName);

assertInternalServerError

Asegura que la respuesta tenga un código de estado HTTP de "Error interno del servidor" (500):

$response->assertInternalServerError();

assertJson

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.

assertJsonCount

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);

assertJsonFragment

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']);

assertJsonIsArray

Asegura que el JSON de la respuesta sea un array:

$response->assertJsonIsArray();

assertJsonIsObject

Asegura que el JSON de la respuesta sea un objeto:

$response->assertJsonIsObject();

assertJsonMissing

Asegura que la respuesta no contenga los datos JSON proporcionados:

$response->assertJsonMissing(array $data);

assertJsonMissingExact

Asegura que la respuesta no contenga los datos JSON exactos:

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

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.

assertJsonPath

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');

assertJsonMissingPath

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');

assertJsonStructure

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'
        ]
    ]
]);

assertJsonValidationErrors

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.

assertJsonValidationErrorFor

Asegura que la respuesta tiene errores de validación JSON para la clave dada:

$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');

assertMethodNotAllowed

Asegura que la respuesta tiene un código de estado HTTP de método no permitido (405):

$response->assertMethodNotAllowed();

assertMovedPermanently

Asegura que la respuesta tiene un código de estado HTTP de movido permanentemente (301):

$response->assertMovedPermanently();

assertLocation

Asegura que la respuesta tiene el valor de URI dado en el encabezado Location:

$response->assertLocation($uri);

assertContent

Asegura que la cadena dada coincide con el contenido de la respuesta:

$response->assertContent($value);

assertNoContent

Asegura que la respuesta tiene el código de estado HTTP dado y sin contenido:

$response->assertNoContent($status = 204);

assertStreamedContent

Asegura que la cadena dada coincide con el contenido transmitido de la respuesta:

$response->assertStreamedContent($value);

assertNotFound

Asegura que la respuesta tiene un código de estado HTTP de no encontrado (404):

$response->assertNotFound();

assertOk

Asegura que la respuesta tiene un código de estado HTTP 200:

$response->assertOk();

assertPaymentRequired

Asegura que la respuesta tiene un código de estado HTTP de pago requerido (402):

$response->assertPaymentRequired();

assertPlainCookie

Asegura que la respuesta contiene la cookie no cifrada dada:

$response->assertPlainCookie($cookieName, $value = null);

assertRedirect

Asegura que la respuesta es una redirección a la URI dada:

$response->assertRedirect($uri = null);

assertRedirectContains

Asegura si la respuesta se redirige a una URI que contiene la cadena dada:

$response->assertRedirectContains($string);

assertRedirectToRoute

Asegura que la respuesta es una redirección a la ruta con nombre dada:

$response->assertRedirectToRoute($name, $parameters = []);

assertRedirectToSignedRoute

Asegura que la respuesta es una redirección a la ruta firmada dada:

$response->assertRedirectToSignedRoute($name = null, $parameters = []);

assertRequestTimeout

Asegura que la respuesta tiene un código de estado HTTP de tiempo de espera de solicitud (408):

$response->assertRequestTimeout();

assertSee

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);

assertSeeInOrder

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);

assertSeeText

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);

assertSeeTextInOrder

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);

assertServerError

Asegura que la respuesta tiene un código de estado HTTP de error de servidor (>= 500, < 600):

$response->assertServerError();

assertServiceUnavailable

Asegura que la respuesta tiene un código de estado HTTP de "Servicio no disponible" (503):

$response->assertServiceUnavailable();

assertSessionHas

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';
});

assertSessionHasInput

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';
});

assertSessionHasAll

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',
]);

assertSessionHasErrors

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.

assertSessionHasErrorsIn

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);

assertSessionHasNoErrors

Asegura que la sesión no tiene errores de validación:

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

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.

assertSessionMissing

Asegura que la sesión no contiene la clave dada:

$response->assertSessionMissing($key);

assertStatus

Asegura que la respuesta tiene un código de estado HTTP dado:

$response->assertStatus($code);

assertSuccessful

Asegura que la respuesta tiene un código de estado HTTP exitoso (>= 200 y < 300):

$response->assertSuccessful();

assertTooManyRequests

Asegura que la respuesta tiene un código de estado HTTP de demasiadas solicitudes (429):

$response->assertTooManyRequests();

assertUnauthorized

Asegura que la respuesta tiene un código de estado HTTP no autorizado (401):

$response->assertUnauthorized();

assertUnprocessable

Asegura que la respuesta tiene un código de estado HTTP de entidad no procesable (422):

$response->assertUnprocessable();

assertUnsupportedMediaType

Asegura que la respuesta tiene un código de estado HTTP de tipo de medio no admitido (415):

$response->assertUnsupportedMediaType();

assertValid

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']);

assertInvalid

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',
]);

assertViewHas

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']);

assertViewHasAll

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',
    'email' => '[email protected],',
]);

assertViewIs

Asegura que la vista dada fue devuelta por la ruta:

$response->assertViewIs($value);

assertViewMissing

Asegura que la clave de datos dada no estuvo disponible para la vista devuelta en la respuesta de la aplicación:

$response->assertViewMissing($key);

Asertos de autenticación

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.

assertAuthenticated

Asegura que un usuario está autenticado:

$this->assertAuthenticated($guard = null);

assertGuest

Asegura que un usuario no está autenticado:

$this->assertGuest($guard = null);

assertAuthenticatedAs

Asegura que un usuario específico está autenticado:

$this->assertAuthenticatedAs($user, $guard = null);

Asertos de validación

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.