Pruebas HTTP

• Introducción
• Realizando solicitudes
  • Personalizando encabezados de solicitud
  • Cookies
  • Sesión / Autenticación
  • Depuración de respuestas
  • Manejo de excepciones
• Probando APIs JSON
  • Pruebas JSON fluidas
• Probando cargas de archivos
• Probando vistas
  • Renderizando Blade y componentes
• Aserciones disponibles
  • Aserciones de respuesta
  • Aserciones de autenticación
  • Aserciones de validación

#Introducción

Laravel proporciona una API muy fluida para realizar solicitudes HTTP a su aplicación y examinar las respuestas. Por ejemplo, observe la prueba funcional 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 verifica que la respuesta devuelta tenga el código de estado HTTP dado. Además de esta simple aserción, Laravel también contiene una variedad de aserciones para inspeccionar los encabezados de respuesta, contenido, estructura JSON y más.

#Realizando solicitudes

Para realizar una solicitud a su aplicación, puede invocar los métodos get, post, put, patch o delete dentro de su prueba. Estos métodos no realizan una solicitud HTTP "real" a su aplicación. En cambio, toda la solicitud de red 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 aserciones útiles que le permiten inspeccionar las respuestas de su 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 sus pruebas debería realizar solo una solicitud a su aplicación. Puede ocurrir un comportamiento inesperado si se ejecutan múltiples solicitudes dentro de un solo método de prueba.

#Personalizando encabezados de solicitud

Puede usar el método withHeaders para personalizar los encabezados de la solicitud antes de enviarla a la aplicación. Este método le permite agregar cualquier encabezado personalizado que desee 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

Puede usar los métodos withCookie o withCookies para establecer valores de cookies antes de realizar 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 arreglo 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 helpers para interactuar con la sesión durante las pruebas HTTP. Primero, puede establecer los datos de la sesión a un arreglo dado usando el método withSession. Esto es útil para cargar la sesión con datos antes de emitir una solicitud a su 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 usa típicamente para mantener el estado del usuario actualmente autenticado. Por lo tanto, el helper actingAs proporciona una forma sencilla de autenticar un usuario dado como el usuario actual. Por ejemplo, podemos usar una factory de modelo para generar y autenticar 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 puede especificar qué guard debe usarse para autenticar al usuario dado pasando el nombre del guard como segundo argumento al método actingAs. El guard que se proporcione al método actingAs también se convertirá en el guard predeterminado durante la prueba:

$this->actingAs($user, 'web')

#Depuración de respuestas

Después de realizar una solicitud de prueba a su aplicación, los métodos dump, dumpHeaders y dumpSession pueden usarse 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, puede 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 puede querer probar que su aplicación está lanzando una excepción específica. Para asegurarse de que la excepción no sea capturada por el manejador de excepciones de Laravel y devuelta como una respuesta HTTP, puede invocar el método withoutExceptionHandling antes de realizar su solicitud:

$response = $this->withoutExceptionHandling()->get('/');

Además, si desea asegurarse de que su aplicación no esté utilizando características que han sido desaprobadas por el lenguaje PHP o las librerías que usa su aplicación, puede invocar el método withoutDeprecationHandling antes de realizar su solicitud. Cuando el manejo de desaprobaciones está deshabilitado, las advertencias de desaprobación se convertirán en excepciones, causando que su prueba falle:

$response = $this->withoutDeprecationHandling()->get('/');

El método assertThrows puede usarse para afirmar que el código dentro de un closure dado lanza una excepción del tipo especificado:

$this->assertThrows(
    fn () => (new ProcessOrder)->execute(),
    OrderInvalid::class
);

#Probando APIs JSON

Laravel también proporciona varios helpers para probar APIs JSON y sus respuestas. Por ejemplo, los métodos json, getJson, postJson, putJson, patchJson, deleteJson y optionsJson pueden usarse para emitir solicitudes JSON con varios verbos HTTP. También puede pasar fácilmente datos y encabezados a estos métodos. Para comenzar, escribamos una prueba para hacer una solicitud POST a /api/user y afirmar que se devolvieron los datos JSON esperados:

<?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 la respuesta JSON pueden accederse como variables de arreglo en la respuesta, lo que facilita inspeccionar los valores individuales devueltos dentro de una respuesta JSON:

$this->assertTrue($response['created']);

#Aserción de coincidencias exactas en JSON

Como se mencionó anteriormente, el método assertJson puede usarse para afirmar que un fragmento de JSON existe dentro de la respuesta JSON. Si desea verificar que un arreglo dado coincida exactamente con el JSON devuelto por su aplicación, debe 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,
            ]);
    }
}

#Aserción en rutas JSON

Si desea verificar que la respuesta JSON contenga los datos dados en una ruta especificada, debe 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 closure, que puede usarse para determinar dinámicamente si la aserción debe pasar:

$response->assertJsonPath('team.owner.name', fn (string $name) => strlen($name) >= 3);

#Pruebas JSON fluidas

Laravel también ofrece una forma elegante de probar fluidamente las respuestas JSON de su aplicación. Para comenzar, pase un closure al método assertJson. Este closure será invocado con una instancia de Illuminate\Testing\Fluent\AssertableJson que puede usarse para hacer aserciones contra el JSON devuelto por su aplicación. El método where puede usarse para hacer aserciones contra un atributo particular del JSON, mientras que el método missing puede usarse para afirmar que un atributo particular está ausente del 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('victoria@gmail.com'))
                 ->whereNot('status', 'pending')
                 ->missing('password')
                 ->etc()
        );
}

#Entendiendo el método etc

En el ejemplo anterior, habrá notado que invocamos el método etc al final de nuestra cadena de aserciones. 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 contra los que no hizo aserciones en el objeto JSON.

La intención detrás de este comportamiento es protegerlo de exponer involuntariamente información sensible en sus respuestas JSON obligándolo a hacer una aserción explícita contra el atributo o permitir explícitamente atributos adicionales mediante el método etc.

Sin embargo, debe tener en cuenta que no incluir el método etc en su cadena de aserciones no garantiza que no se estén agregando atributos adicionales a arreglos anidados dentro de su 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.

#Aserción de presencia / ausencia de atributos

Para afirmar que un atributo está presente o ausente, puede 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'])
);

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

#Aserción contra colecciones JSON

A menudo, su ruta devolverá una respuesta JSON que contiene múltiples elementos, como múltiples usuarios:

Route::get('/users', function () {
    return User::all();
});

En estas situaciones, podemos usar el método has del objeto JSON fluido para hacer aserciones contra los usuarios incluidos en la respuesta. Por ejemplo, afirmemos que la respuesta JSON contiene tres usuarios. Luego, haremos algunas aserciones sobre el primer usuario en la colección usando el método first. El método first acepta un closure que recibe otro objeto JSON asertable que podemos usar para hacer aserciones 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('victoria@gmail.com'))
                     ->missing('password')
                     ->etc()
             )
    );

#Limitando el alcance de aserciones en colecciones JSON

A veces, las rutas de su aplicación devolverán colecciones JSON que están asignadas a claves nombradas:

Route::get('/users', function () {
    return [
        'meta' => [...],
        'users' => User::all(),
    ];
})

Al probar estas rutas, puede usar el método has para afirmar contra el número de elementos en la colección. Además, puede usar el método has para limitar una cadena de aserciones:

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

Sin embargo, en lugar de hacer dos llamadas separadas al método has para afirmar contra la colección users, puede hacer una sola llamada que proporcione un closure como tercer parámetro. Al hacerlo, el closure será invocado automáticamente y limitado 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('victoria@gmail.com'))
                     ->missing('password')
                     ->etc()
             )
    );

#Aserción de tipos JSON

Puede que solo quiera 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'
        ])
);

Puede especificar múltiples tipos usando el carácter |, o pasando un arreglo de tipos como segundo parámetro al método whereType. La aserción tendrá éxito si el valor de la respuesta es cualquiera de los tipos listados:

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

#Probando cargas de archivos

La clase Illuminate\Http\UploadedFile proporciona un método fake que puede usarse para generar archivos o imágenes ficticias para pruebas. Esto, combinado con el método fake del facade Storage, simplifica enormemente la prueba de cargas de archivos. Por ejemplo, puede 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 desea afirmar que un archivo dado no existe, puede usar el método assertMissing proporcionado por el facade Storage:

Storage::fake('avatars');

// ...

Storage::disk('avatars')->assertMissing('missing.jpg');

#Personalización de archivos ficticios

Al crear archivos usando el método fake proporcionado por la clase UploadedFile, puede especificar el ancho, alto y tamaño de la imagen (en kilobytes) para probar mejor las reglas de validación de su aplicación:

UploadedFile::fake()->image('avatar.jpg', $width, $height)->size(100);

Además de crear imágenes, puede crear archivos de cualquier otro tipo usando el método create:

UploadedFile::fake()->create('document.pdf', $sizeInKilobytes);

Si es necesario, puede pasar un argumento $mimeType al método para definir explícitamente el tipo MIME que debe devolver el archivo:

UploadedFile::fake()->create(
    'document.pdf', $sizeInKilobytes, 'application/pdf'
);

#Probando vistas

Laravel también le permite renderizar una vista sin hacer una solicitud HTTP simulada a la aplicación. Para lograr esto, puede llamar al método view dentro de su prueba. El método view acepta el nombre de la vista y un arreglo opcional de datos. El método devuelve una instancia de Illuminate\Testing\TestView, que ofrece varios métodos para hacer aserciones convenientemente 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 aserción: assertSee, assertSeeInOrder, assertSeeText, assertSeeTextInOrder, assertDontSee y assertDontSeeText.

Si es necesario, puede obtener el contenido renderizado en bruto de la vista convirtiendo la instancia TestView a una cadena:

$contents = (string) $this->view('welcome');

#Compartiendo errores

Algunas vistas pueden depender de errores compartidos en la bolsa global de errores proporcionada por Laravel. Para hidratar la bolsa de errores con mensajes de error, puede usar el método withViewErrors:

$view = $this->withViewErrors([
    'name' => ['Por favor, proporcione un nombre válido.']
])->view('form');

$view->assertSee('Por favor, proporcione un nombre válido.');

#Renderizando Blade y componentes

Si es necesario, puede usar el método blade para evaluar y renderizar una cadena cruda de Blade. 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');

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

#Aserciones disponibles

#Aserciones de respuesta

La clase Illuminate\Testing\TestResponse de Laravel proporciona una variedad de métodos de aserción personalizados que puede utilizar al probar su aplicación. Estas aserciones pueden accederse en la respuesta que devuelven los métodos de prueba json, get, post, put y delete:

#assertBadRequest

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

$response->assertBadRequest();

#assertAccepted

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

$response->assertAccepted();

#assertConflict

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

$response->assertConflict();

#assertCookie

Asegure que la respuesta contenga la cookie dada:

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

#assertCookieExpired

Asegure que la respuesta contenga la cookie dada y que esté expirada:

$response->assertCookieExpired($cookieName);

#assertCookieNotExpired

Asegure que la respuesta contenga la cookie dada y que no esté expirada:

$response->assertCookieNotExpired($cookieName);

#assertCookieMissing

Asegure que la respuesta no contenga la cookie dada:

$response->assertCookieMissing($cookieName);

#assertCreated

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

$response->assertCreated();

#assertDontSee

Asegure que la cadena dada no esté contenida dentro de la respuesta devuelta por la aplicación. Esta aserción escapará automáticamente la cadena dada a menos que pase un segundo argumento de false:

$response->assertDontSee($value, $escaped = true);

#assertDontSeeText

Asegure que la cadena dada no esté contenida dentro del texto de la respuesta. Esta aserción escapará automáticamente la cadena dada a menos que pase un segundo argumento de false. Este método pasará el contenido de la respuesta a la función PHP strip_tags antes de hacer la aserción:

$response->assertDontSeeText($value, $escaped = true);

#assertDownload

Asegure que la respuesta sea una "descarga". Normalmente, esto significa que la ruta invocada que devolvió la respuesta retornó una respuesta Response::download, BinaryFileResponse o Storage::download:

$response->assertDownload();

Si lo desea, puede asegurar que el archivo descargable tenga un nombre de archivo dado:

$response->assertDownload('image.jpg');

#assertExactJson

Asegure que la respuesta contenga una coincidencia exacta de los datos JSON dados:

$response->assertExactJson(array $data);

#assertForbidden

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

$response->assertForbidden();

#assertFound

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

$response->assertFound();

#assertGone

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

$response->assertGone();

#assertHeader

Asegure que el encabezado y valor dados estén presentes en la respuesta:

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

#assertHeaderMissing

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

$response->assertHeaderMissing($headerName);

#assertInternalServerError

Asegure que la respuesta tenga un código de estado HTTP de "Error Interno del Servidor" (500):

$response->assertInternalServerError();

#assertJson

Asegure que la respuesta contenga los datos JSON dados:

$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 exista dentro de la respuesta JSON devuelta por la aplicación. Por lo tanto, si hay otras propiedades en la respuesta JSON, esta prueba aún pasará siempre que el fragmento dado esté presente.

#assertJsonCount

Asegure 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

Asegure que la respuesta contenga los datos JSON dados en cualquier parte de la respuesta:

Route::get('/users', function () {
    return [
        'users' => [
            [
                'name' => 'Taylor Otwell',
            ],
        ],
    ];
});

$response->assertJsonFragment(['name' => 'Taylor Otwell']);

#assertJsonIsArray

Asegure que el JSON de la respuesta sea un array:

$response->assertJsonIsArray();

#assertJsonIsObject

Asegure que el JSON de la respuesta sea un objeto:

$response->assertJsonIsObject();

#assertJsonMissing

Asegure que la respuesta no contenga los datos JSON dados:

$response->assertJsonMissing(array $data);

#assertJsonMissingExact

Asegure que la respuesta no contenga exactamente los datos JSON dados:

$response->assertJsonMissingExact(array $data);

#assertJsonMissingValidationErrors

Asegure que la respuesta no tenga errores de validación JSON para las claves dadas:

$response->assertJsonMissingValidationErrors($keys);

#assertJsonPath

Asegure que la respuesta contenga los datos dados en la ruta especificada:

$response->assertJsonPath($path, $expectedValue);

Por ejemplo, si la siguiente respuesta JSON es devuelta por su aplicación:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puede asegurar que la propiedad name del objeto user coincida con un valor dado así:

$response->assertJsonPath('user.name', 'Steve Schoger');

#assertJsonMissingPath

Asegure que la respuesta no contenga la ruta dada:

$response->assertJsonMissingPath($path);

Por ejemplo, si la siguiente respuesta JSON es devuelta por su aplicación:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puede asegurar que no contenga la propiedad email del objeto user:

$response->assertJsonMissingPath('user.email');

#assertJsonStructure

Asegure que la respuesta tenga una estructura JSON dada:

$response->assertJsonStructure(array $structure);

Por ejemplo, si la respuesta JSON devuelta por su aplicación contiene los siguientes datos:

{
    "user": {
        "name": "Steve Schoger"
    }
}

Puede asegurar que la estructura JSON coincida con sus expectativas así:

$response->assertJsonStructure([
    'user' => [
        'name',
    ]
]);

A veces, las respuestas JSON devueltas por su 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, puede usar el carácter * para asegurar la estructura de todos los objetos en el array:

$response->assertJsonStructure([
    'user' => [
        '*' => [
             'name',
             'age',
             'location'
        ]
    ]
]);

#assertJsonValidationErrors

Asegure que la respuesta tenga los errores de validación JSON dados para las claves dadas. Este método debe usarse cuando se hacen aserciones contra respuestas donde los errores de validación se devuelven como una estructura JSON en lugar de ser almacenados en la sesión:

$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');

#assertJsonValidationErrorFor

Asegure que la respuesta tenga cualquier error de validación JSON para la clave dada:

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

#assertMethodNotAllowed

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

$response->assertMethodNotAllowed();

#assertMovedPermanently

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

$response->assertMovedPermanently();

#assertLocation

Asegure que la respuesta tenga el valor URI dado en el encabezado Location:

$response->assertLocation($uri);

#assertContent

Asegure que la cadena dada coincida con el contenido de la respuesta:

$response->assertContent($value);

#assertNoContent

Asegure que la respuesta tenga el código de estado HTTP dado y no tenga contenido:

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

#assertStreamedContent

Asegure que la cadena dada coincida con el contenido transmitido de la respuesta:

$response->assertStreamedContent($value);

#assertNotFound

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

$response->assertNotFound();

#assertOk

Asegure que la respuesta tenga un código de estado HTTP 200:

$response->assertOk();

#assertPaymentRequired

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

$response->assertPaymentRequired();

#assertPlainCookie

Asegure que la respuesta contenga la cookie sin cifrar dada:

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

#assertRedirect

Asegure que la respuesta sea una redirección a la URI dada:

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

#assertRedirectContains

Asegure si la respuesta está redirigiendo a una URI que contiene la cadena dada:

$response->assertRedirectContains($string);

#assertRedirectToRoute

Asegure que la respuesta sea una redirección a la ruta nombrada dada:

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

#assertRedirectToSignedRoute

Asegure que la respuesta sea una redirección a la ruta firmada dada:

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

#assertRequestTimeout

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

$response->assertRequestTimeout();

#assertSee

Asegure que la cadena dada esté contenida dentro de la respuesta. Esta aserción escapará automáticamente la cadena dada a menos que pase un segundo argumento de false:

$response->assertSee($value, $escaped = true);

#assertSeeInOrder

Asegure que las cadenas dadas estén contenidas en orden dentro de la respuesta. Esta aserción escapará automáticamente las cadenas dadas a menos que pase un segundo argumento de false:

$response->assertSeeInOrder(array $values, $escaped = true);

#assertSeeText

Asegure que la cadena dada esté contenida dentro del texto de la respuesta. Esta aserción escapará automáticamente la cadena dada a menos que pase un segundo argumento de false. El contenido de la respuesta será pasado a la función PHP strip_tags antes de hacer la aserción:

$response->assertSeeText($value, $escaped = true);

#assertSeeTextInOrder

Asegure que las cadenas dadas estén contenidas en orden dentro del texto de la respuesta. Esta aserción escapará automáticamente las cadenas dadas a menos que pase un segundo argumento de false. El contenido de la respuesta será pasado a la función PHP strip_tags antes de hacer la aserción:

$response->assertSeeTextInOrder(array $values, $escaped = true);

#assertServerError

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

$response->assertServerError();

#assertServiceUnavailable

Asegure que la respuesta tenga un código de estado HTTP de "Servicio No Disponible" (503):

$response->assertServiceUnavailable();

#assertSessionHas

Asegure que la sesión contenga el dato dado:

$response->assertSessionHas($key, $value = null);

Si es necesario, se puede proporcionar un closure como segundo argumento al método assertSessionHas. La aserción pasará si el closure devuelve true:

$response->assertSessionHas($key, function (User $value) {
    return $value->name === 'Taylor Otwell';
});

#assertSessionHasInput

Asegure que la sesión tenga un valor dado en el array de entrada flash:

$response->assertSessionHasInput($key, $value = null);

Si es necesario, se puede proporcionar un closure como segundo argumento al método assertSessionHasInput. La aserción pasará si el closure devuelve true:

use Illuminate\Support\Facades\Crypt;

$response->assertSessionHasInput($key, function (string $value) {
    return Crypt::decryptString($value) === 'secret';
});

#assertSessionHasAll

Asegure que la sesión contenga un array dado de pares clave / valor:

$response->assertSessionHasAll(array $data);

Por ejemplo, si la sesión de su aplicación contiene las claves name y status, puede asegurar que ambas existan y tengan los valores especificados así:

$response->assertSessionHasAll([
    'name' => 'Taylor Otwell',
    'status' => 'active',
]);

#assertSessionHasErrors

Asegure que la sesión contenga un error para las $keys dadas. Si $keys es un array asociativo, asegure que la sesión contenga 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 asegurar que los campos name y email tengan mensajes de error de validación que fueron almacenados en la sesión, puede invocar el método assertSessionHasErrors así:

$response->assertSessionHasErrors(['name', 'email']);

O puede asegurar que un campo dado tenga un mensaje de error de validación particular:

$response->assertSessionHasErrors([
    'name' => 'The given name was invalid.'
]);

#assertSessionHasErrorsIn

Asegure que la sesión contenga un error para las $keys dadas dentro de una bolsa de errores específica. Si $keys es un array asociativo, asegure que la sesión contenga un mensaje de error específico (valor) para cada campo (clave), dentro de la bolsa de errores:

$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);

#assertSessionHasNoErrors

Asegure que la sesión no tenga errores de validación:

$response->assertSessionHasNoErrors();

#assertSessionDoesntHaveErrors

Asegure que la sesión no tenga errores de validación para las claves dadas:

$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');

#assertSessionMissing

Asegure que la sesión no contenga la clave dada:

$response->assertSessionMissing($key);

#assertStatus

Asegure que la respuesta tenga un código de estado HTTP dado:

$response->assertStatus($code);

#assertSuccessful

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

$response->assertSuccessful();

#assertTooManyRequests

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

$response->assertTooManyRequests();

#assertUnauthorized

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

$response->assertUnauthorized();

#assertUnprocessable

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

$response->assertUnprocessable();

#assertUnsupportedMediaType

Asegure que la respuesta tenga un código de estado HTTP de tipo de medio no soportado (415):

$response->assertUnsupportedMediaType();

#assertValid

Asegure que la respuesta no tenga errores de validación para las claves dadas. Este método puede usarse para hacer aserciones contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación han sido almacenados en la sesión:

// Asegurar que no haya errores de validación presentes...
$response->assertValid();

// Asegurar que las claves dadas no tengan errores de validación...
$response->assertValid(['name', 'email']);

#assertInvalid

Asegure que la respuesta tenga errores de validación para las claves dadas. Este método puede usarse para hacer aserciones contra respuestas donde los errores de validación se devuelven como una estructura JSON o donde los errores de validación han sido almacenados en la sesión:

$response->assertInvalid(['name', 'email']);

También puede asegurar que una clave dada tenga un mensaje de error de validación particular. Al hacerlo, puede 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 la respuesta contiene un dato específico:

$response->assertViewHas($key, $value = null);

Pasar una closure como segundo argumento al método assertViewHas le permitirá inspeccionar y hacer aserciones sobre un dato particular de la vista:

$response->assertViewHas('user', function (User $user) {
    return $user->name === 'Taylor';
});

Además, los datos de la vista pueden accederse como variables de arreglo en la respuesta, lo que le permite inspeccionarlos cómodamente:

$this->assertEquals('Taylor', $response['name']);

#assertViewHasAll

Asegura que la vista de la respuesta contiene una lista dada de datos:

$response->assertViewHasAll(array $data);

Este método puede usarse para asegurar que la vista simplemente contiene datos que coinciden con las claves dadas:

$response->assertViewHasAll([
    'name',
    'email',
]);

O bien, puede asegurar que los datos de la vista están presentes y tienen valores específicos:

$response->assertViewHasAll([
    'name' => 'Taylor Otwell',
    'email' => 'taylor@example.com,',
]);

#assertViewIs

Asegura que la vista dada fue retornada por la ruta:

$response->assertViewIs($value);

#assertViewMissing

Asegura que la clave de dato dada no estuvo disponible en la vista retornada en la respuesta de la aplicación:

$response->assertViewMissing($key);

#Aserciones de Autenticación

Laravel también proporciona una variedad de aserciones relacionadas con la autenticación que puede utilizar dentro de las pruebas funcionales de su aplicación. Tenga en cuenta que estos métodos se invocan en la clase de prueba misma y no en la instancia Illuminate\Testing\TestResponse retornada 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);

#Aserciones de Validación

Laravel proporciona dos aserciones principales relacionadas con la validación que puede usar para asegurar que los datos proporcionados en su solicitud fueron válidos o inválidos.

#assertValid

Asegura que la respuesta no tiene errores de validación para las claves dadas. Este método puede usarse para aserciones contra respuestas donde los errores de validación se retornan como una estructura JSON o donde los errores de validación han sido almacenados en la sesión:

// Asegurar que no hay errores de validación presentes...
$response->assertValid();

// Asegurar que las claves dadas no tienen 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 puede usarse para aserciones contra respuestas donde los errores de validación se retornan como una estructura JSON o donde los errores de validación han sido almacenados en la sesión:

$response->assertInvalid(['name', 'email']);

También puede asegurar que una clave dada tiene un mensaje de error de validación particular. Al hacerlo, puede proporcionar el mensaje completo o solo una pequeña parte del mensaje:

$response->assertInvalid([
    'name' => 'The name field is required.',
    'email' => 'valid email address',
]);