HTTP 测试

介绍

Laravel 提供了一个流式 API，用于向您的应用程序发送 HTTP 请求并检查响应。例如，请看下面定义的 功能测试：

<?php

test('the application returns a successful response', function () {
    $response = $this->get('/');

    $response->assertStatus(200);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_the_application_returns_a_successful_response(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

get 方法向应用程序发出一个 GET 请求，而 assertStatus 方法则断言返回的响应应具有给定的 HTTP 状态码。除了这个简单的断言，Laravel 还包含了各种断言，用于检查响应头、内容、JSON 结构等。

发起请求

要向您的应用程序发起请求，您可以在测试中调用 get、post、put、patch 或 delete 方法。这些方法实际上并不向您的应用程序发出 “真正的” HTTP 请求。相反，整个网络请求是在内部模拟的。

测试请求方法不会返回 Illuminate\Http\Response 实例，而是返回 Illuminate\Testing\TestResponse 的实例，它提供了各种有用的断言，允许您检查应用程序的响应：

<?php

test('basic request', function () {
    $response = $this->get('/');

    $response->assertStatus(200);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_a_basic_request(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

通常，您的每个测试只应向应用程序发起一个请求。如果在单个测试方法中执行多次请求，可能会出现意外行为。

为方便起见，在运行测试时，CSRF 中间件会自动被禁用。

自定义请求头

您可以使用 withHeaders 方法在请求发送到应用程序之前自定义其请求头。此方法允许您向请求添加任何您想要的自定义头：

<?php

test('interacting with cookies', function () {
    $response = $this->withCookie('color', 'blue')->get('/');

    $response = $this->withCookies([
        'color' => 'blue',
        'name' => 'Taylor',
    ])->get('/');

    //
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic functional test example.
     */
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

Cookies

您可以使用 withCookie 或 withCookies 方法在发起请求之前设置 cookie 值。withCookie 方法接受 cookie 名称和值作为其两个参数，而 withCookies 方法接受一个名称/值对的数组：

<?php

test('interacting with cookies', function () {
    $response = $this->withCookie('color', 'blue')->get('/');

    $response = $this->withCookies([
        'color' => 'blue',
        'name' => 'Taylor',
    ])->get('/');

    //
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic functional test example.
     */
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

会话 / 认证

Laravel 提供了几个在 HTTP 测试期间与会话交互的辅助方法。首先，您可以使用 withSession 方法将会话数据设置为给定的数组。这在向您的应用程序发出请求之前用数据加载会话非常有用：

<?php

test('interacting with the session', function () {
    $response = $this->withSession(['banned' => false])->get('/');

    //
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_interacting_with_the_session(): void
    {
        $response = $this->withSession(['banned' => false])->get('/');

        //
    }
}

Laravel 的会话通常用于维护当前认证用户的状态。因此，actingAs 辅助方法提供了一种简单的方法来将给定用户认证为当前用户。例如，我们可以使用模型工厂来生成和认证一个用户：

<?php

use App\Models\User;

test('an action that requires authentication', function () {
    $user = User::factory()->create();

    $response = $this->actingAs($user)
        ->withSession(['banned' => false])
        ->get('/');

    //
});

<?php

namespace Tests\Feature;

use App\Models\User;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_an_action_that_requires_authentication(): void
    {
        $user = User::factory()->create();

        $response = $this->actingAs($user)
            ->withSession(['banned' => false])
            ->get('/');

        //
    }
}

您还可以通过将守卫名称作为第二个参数传递给 actingAs 方法来指定应使用哪个守卫来认证给定用户。传递给 actingAs 方法的守卫也将成为测试期间的默认守卫：

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

如果您想确保请求是未认证的，可以使用 actingAsGuest 方法：

$this->actingAsGuest();

调试响应

在向您的应用程序发起测试请求后，可以使用 dump、dumpHeaders 和 dumpSession 方法来检查和调试响应内容：

<?php

test('basic test', function () {
    $response = $this->get('/');

    $response->dump();
    $response->dumpHeaders();
    $response->dumpSession();
});

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

        //
    }
}

或者，您可以使用 dd、ddHeaders、ddBody、ddJson 和 ddSession 方法来转储有关响应的信息，然后停止执行：

<?php

test('basic test', function () {
    $response = $this->get('/');

    $response->dd();
    $response->ddHeaders();
    $response->ddBody();
    $response->ddJson();
    $response->ddSession();
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');

        $response->dd();
        $response->ddHeaders();
        $response->ddBody();
        $response->ddJson();
        $response->ddSession();
    }
}

异常处理

有时您可能需要测试您的应用程序是否正在抛出特定的异常。为此，您可以通过 Exceptions facade “伪造”（fake）异常处理程序。一旦异常处理程序被伪造，您就可以使用 assertReported 和 assertNotReported 方法来对请求期间抛出的异常进行断言：

<?php

use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;

test('exception is thrown', function () {
    Exceptions::fake();

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

    // Assert an exception was thrown...
    Exceptions::assertReported(InvalidOrderException::class);

    // Assert against the exception...
    Exceptions::assertReported(function (InvalidOrderException $e) {
        return $e->getMessage() === 'The order was invalid.';
    });
});

<?php

namespace Tests\Feature;

use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_exception_is_thrown(): void
    {
        Exceptions::fake();

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

        // Assert an exception was thrown...
        Exceptions::assertReported(InvalidOrderException::class);

        // Assert against the exception...
        Exceptions::assertReported(function (InvalidOrderException $e) {
            return $e->getMessage() === 'The order was invalid.';
        });
    }
}

assertNotReported 和 assertNothingReported 方法可用于断言在请求期间未抛出给定异常，或者根本没有抛出任何异常：

Exceptions::assertNotReported(InvalidOrderException::class);
 
Exceptions::assertNothingReported();

您可以通过在发起请求之前调用 withoutExceptionHandling 方法来完全禁用给定请求的异常处理：

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

此外，如果您想确保您的应用程序没有使用被 PHP 语言或您的应用程序使用的库弃用的功能，您可以在发起请求之前调用 withoutDeprecationHandling 方法。当弃用处理被禁用时，弃用警告将被转换为异常，从而导致您的测试失败：

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

assertThrows 方法可用于断言给定闭包中的代码抛出了指定类型的异常：

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

如果您想检查并对抛出的异常进行断言，您可以将闭包作为第二个参数传递给 assertThrows 方法：

$this->assertThrows(
    fn () => (new ProcessOrder)->execute(),
    fn (OrderInvalid $e) => $e->orderId() === 123;
);

assertDoesntThrow 方法可用于断言给定闭包中的代码不会抛出任何异常：

$this->assertDoesntThrow(fn () => (new ProcessOrder)->execute());

Laravel 还提供了几个辅助方法用于测试 JSON API 及其响应。例如，json、getJson、postJson、putJson、patchJson、deleteJson 和 optionsJson 方法可用于使用各种 HTTP 动词发出 JSON 请求。您还可以轻松地将数据和头信息传递给这些方法。为了开始，让我们编写一个测试，向 /api/user 发起一个 POST 请求，并断言返回了预期的 JSON 数据：

<?php

test('making an api request', function () {
    $response = $this->postJson('/api/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertJson([
            'created' => true,
        ]);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic functional test example.
     */
    public function test_making_an_api_request(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertJson([
                'created' => true,
            ]);
    }
}

此外，JSON 响应数据可以作为响应上的数组变量进行访问，这使得您可以方便地检查 JSON 响应中返回的单个值：

expect($response['created'])->toBeTrue();

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

assertJson 方法将响应转换为数组，以验证给定数组存在于应用程序返回的 JSON 响应中。因此，如果 JSON 响应中存在其他属性，只要给定的片段存在，此测试仍然会通过。

断言精确的 JSON 匹配

如前所述，assertJson 方法可用于断言 JSON 片段存在于 JSON 响应中。如果您想验证给定的数组精确匹配应用程序返回的 JSON，您应该使用 assertExactJson 方法：

<?php

test('asserting an exact json match', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertExactJson([
            'created' => true,
        ]);
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic functional test example.
     */
    public function test_asserting_an_exact_json_match(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertExactJson([
                'created' => true,
            ]);
    }
}

对 JSON 路径进行断言

如果您想验证 JSON 响应在指定的路径上包含给定的数据，您应该使用 assertJsonPath 方法：

<?php

test('asserting a json path value', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);

    $response
        ->assertStatus(201)
        ->assertJsonPath('team.owner.name', 'Darian');
});

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic functional test example.
     */
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

        $response
            ->assertStatus(201)
            ->assertJsonPath('team.owner.name', 'Darian');
    }
}

assertJsonPath 方法还接受一个闭包，可用于动态确定断言是否应通过：

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

流式 JSON 测试

Laravel 还提供了一种漂亮的方式来流畅地测试您的应用程序的 JSON 响应。要开始，将一个闭包传递给 assertJson 方法。这个闭包将使用 Illuminate\Testing\Fluent\AssertableJson 的实例进行调用，该实例可用于对应用程序返回的 JSON 进行断言。where 方法可用于对 JSON 的特定属性进行断言，而 missing 方法可用于断言 JSON 中缺少特定属性：

use Illuminate\Testing\Fluent\AssertableJson;

test('fluent json', function () {
    $response = $this->getJson('/users/1');

    $response
        ->assertJson(fn (AssertableJson $json) =>
            $json->where('id', 1)
                ->where('name', 'Victoria Faith')
                ->where('email', fn (string $email) => str($email)->is('victoria@gmail.com'))
                ->whereNot('status', 'pending')
                ->missing('password')
                ->etc()
        );
});

use Illuminate\Testing\Fluent\AssertableJson;

/**
 * A basic functional test example.
 */
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()
        );
}

理解 etc 方法

在上面的示例中，您可能注意到我们在断言链的末尾调用了 etc 方法。此方法通知 Laravel JSON 对象上可能存在其他属性。如果未使用 etc 方法，如果 JSON 对象上存在您没有对其进行断言的其他属性，则测试将失败。

这种行为的目的是通过强制您要么显式地对属性进行断言，要么通过 etc 方法显式地允许附加属性，从而保护您免于在 JSON 响应中无意中暴露敏感信息。

但是，您应该意识到，在断言链中不包含 etc 方法并不能确保不会将附加属性添加到嵌套在 JSON 对象中的数组中。etc 方法仅确保在调用 etc 方法的嵌套级别上不存在附加属性。

断言属性存在/缺失

要断言属性存在或缺失，您可以使用 has 和 missing 方法：

$response->assertJson(fn (AssertableJson $json) =>
    $json->has('data')
        ->missing('message')
);

此外，hasAll 和 missingAll 方法允许同时断言多个属性的存在或缺失：

$response->assertJson(fn (AssertableJson $json) =>
    $json->hasAll(['status', 'data'])
        ->missingAll(['message', 'code'])
);

您可以使用 hasAny 方法来确定给定属性列表中的至少一个是否存在：

$response->assertJson(fn (AssertableJson $json) =>
    $json->has('status')
        ->hasAny('data', 'message', 'code')
);

对 JSON 集合进行断言

通常，您的路由将返回一个包含多个项目的 JSON 响应，例如多个用户：

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

在这种情况下，我们可以使用流畅的 JSON 对象的 has 方法来对响应中包含的用户进行断言。例如，让我们断言 JSON 响应包含三个用户。接下来，我们将使用 first 方法对集合中的第一个用户进行一些断言。first 方法接受一个闭包，该闭包接收另一个可断言的 JSON 字符串，我们可以用它来对 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()
            )
    );

限定 JSON 集合断言

有时，您的应用程序的路由会返回被分配了命名键的 JSON 集合：

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

在测试这些路由时，您可以使用 has 方法来断言集合中的项目数量。此外，您可以使用 has 方法来限定一系列断言：

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

但是，您可以通过调用单个 has 方法，并将其第三个参数作为闭包，而不是对 users 集合进行两次单独的 has 方法调用。这样做时，闭包将自动被调用并限定在集合中的第一个项目：

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

断言 JSON 类型

您可能只想断言 JSON 响应中的属性是某种类型。Illuminate\Testing\Fluent\AssertableJson 类提供了 whereType 和 whereAllType 方法来实现这一点：

$response->assertJson(fn (AssertableJson $json) =>
    $json->whereType('id', 'integer')
        ->whereAllType([
            'users.0.name' => 'string',
            'meta' => 'array'
        ])
);

您可以使用 | 字符指定多种类型，或者将类型数组作为第二个参数传递给 whereType 方法。如果响应值是列出的任何类型，断言将成功：

$response->assertJson(fn (AssertableJson $json) =>
    $json->whereType('name', 'string|null')
        ->whereType('id', ['string', 'integer'])
);

whereType 和 whereAllType 方法识别以下类型：string、integer、double、boolean、array 和 null。

测试文件上传

Illuminate\Http\UploadedFile 类提供了一个 fake 方法，可用于生成用于测试的虚拟文件或图像。这与 Storage facade 的 fake 方法相结合，极大地简化了文件上传的测试。例如，您可以将这两个功能结合起来，轻松测试头像上传表单：

<?php

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

test('avatars can be uploaded', function () {
    Storage::fake('avatars');

    $file = UploadedFile::fake()->image('avatar.jpg');

    $response = $this->post('/avatar', [
        'avatar' => $file,
    ]);

    Storage::disk('avatars')->assertExists($file->hashName());
});

<?php

namespace Tests\Feature;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_avatars_can_be_uploaded(): void
    {
        Storage::fake('avatars');

        $file = UploadedFile::fake()->image('avatar.jpg');

        $response = $this->post('/avatar', [
            'avatar' => $file,
        ]);

        Storage::disk('avatars')->assertExists($file->hashName());
    }
}

如果您想断言给定文件不存在，可以使用 Storage facade 提供的 assertMissing 方法：

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

伪造文件自定义

当使用 UploadedFile 类提供的 fake 方法创建文件时，您可以指定图像的宽度、高度和大小（以千字节为单位），以便更好地测试应用程序的验证规则：

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

除了创建图像，您还可以使用 create 方法创建任何其他类型的文件：

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

如果需要，您可以向该方法传递一个 $mimeType 参数，以显式定义文件应返回的 MIME 类型：

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

测试视图

Laravel 还允许您在不向应用程序发起模拟 HTTP 请求的情况下渲染视图。为此，您可以在测试中调用 view 方法。view 方法接受视图名称和一个可选的数据数组。该方法返回 Illuminate\Testing\TestView 的实例，它提供了几种方法来方便地对视图内容进行断言：

<?php

test('a welcome view can be rendered', function () {
    $view = $this->view('welcome', ['name' => 'Taylor']);

    $view->assertSee('Taylor');
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_a_welcome_view_can_be_rendered(): void
    {
        $view = $this->view('welcome', ['name' => 'Taylor']);
 
        $view->assertSee('Taylor');
    }
}

TestView 类提供了以下断言方法：assertSee、assertSeeInOrder、assertSeeText、assertSeeTextInOrder、assertDontSee 和 assertDontSeeText。

如果需要，您可以通过将 TestView 实例转换为字符串来获取原始的、已渲染的视图内容：

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

共享错误

某些视图可能依赖于 Laravel 提供的全局错误包中共享的错误。要用错误消息填充错误包，您可以使用 withViewErrors 方法：

$view = $this->withViewErrors([
    'name' => ['Please provide a valid name.']
])->view('form');
 
$view->assertSee('Please provide a valid name.');

渲染 Blade 和组件

如果需要，您可以使用 blade 方法来评估和渲染原始的 Blade 字符串。像 view 方法一样，blade 方法返回 Illuminate\Testing\TestView 的实例：

$view = $this->blade(
    '<x-component :name="$name" />',
    ['name' => 'Taylor']
);
 
$view->assertSee('Taylor');

您可以使用 component 方法来评估和渲染一个 Blade 组件。component 方法返回 Illuminate\Testing\TestComponent 的实例：

$view = $this->component(Profile::class, ['name' => 'Taylor']);
 
$view->assertSee('Taylor');

可用的断言

响应断言

Laravel 的 Illuminate\Testing\TestResponse 类提供了各种自定义断言方法，您可以在测试应用程序时使用它们。这些断言可以在 json、get、post、put 和 delete 测试方法返回的响应上访问：

assertAccepted 断言响应具有接受（202）HTTP 状态码。
assertBadRequest 断言响应具有错误请求（400）HTTP 状态码。
assertClientError 断言响应具有客户端错误（>= 400, < 500）HTTP 状态码。
assertConflict 断言响应具有冲突（409）HTTP 状态码。
assertCookie 断言响应包含给定的 cookie。
assertCookieExpired 断言响应包含给定的 cookie 且已过期。
assertCookieNotExpired 断言响应包含给定的 cookie 且未过期。
assertCookieMissing 断言响应不包含给定的 cookie。
assertCreated 断言响应具有 201 HTTP 状态码。
assertDontSee 断言响应中不包含给定字符串。
assertDontSeeText 断言响应文本中不包含给定字符串。
assertDownload 断言响应是“下载”。
assertExactJson 断言响应包含与给定 JSON 数据完全匹配的内容。
assertExactJsonStructure 断言响应包含与给定 JSON 结构完全匹配的内容。
assertForbidden 断言响应具有禁止（403）HTTP 状态码。
assertFound 断言响应具有已找到（302）HTTP 状态码。
assertGone 断言响应具有已失效（410）HTTP 状态码。
assertHeader 断言响应上存在给定的头和值。
assertHeaderMissing 断言响应上不存在给定的头。
assertInternalServerError 断言响应具有“内部服务器错误”（500）HTTP 状态码。
assertJson 断言响应包含给定的 JSON 数据。
assertJsonCount 断言响应 JSON 在给定键处有一个具有预期项目数量的数组。
assertJsonFragment 断言响应中的任何位置都包含给定的 JSON 数据。
assertJsonIsArray 断言响应 JSON 是一个数组。
assertJsonIsObject 断言响应 JSON 是一个对象。
assertJsonMissing 断言响应不包含给定的 JSON 数据。
assertJsonMissingExact 断言响应不包含精确的 JSON 数据。
assertJsonMissingValidationErrors 断言响应对于给定的键没有 JSON 验证错误。
assertJsonPath 断言响应在指定的路径上包含给定的数据。
assertJsonMissingPath 断言响应不包含给定的路径。
assertJsonStructure 断言响应具有给定的 JSON 结构。
assertJsonValidationErrors 断言响应对于给定的键具有 JSON 验证错误。
assertJsonValidationErrorFor 断言响应对于给定的键具有任何 JSON 验证错误。
assertLocation 断言响应在 Location 头中具有给定的 URI 值。
assertMethodNotAllowed 断言响应具有方法不允许（405）HTTP 状态码。
assertMovedPermanently 断言响应具有永久移动（301）HTTP 状态码。
assertContent 断言给定字符串与响应内容匹配。
assertNoContent 断言响应具有给定的 HTTP 状态码且没有内容。
assertStreamed 断言响应是流式响应。
assertStreamedContent 断言给定字符串与流式响应内容匹配。
assertNotFound 断言响应具有未找到（404）HTTP 状态码。
assertOk 断言响应具有 200 HTTP 状态码。
assertPaymentRequired 断言响应具有需要付款（402）HTTP 状态码。
assertPlainCookie 断言响应包含给定的未加密 cookie。
assertRedirect 断言响应是重定向。
assertRedirectBack 断言响应是重定向回前一个 URL。
assertRedirectBackWithErrors 断言响应是重定向回前一个 URL，并带有错误。
assertRedirectBackWithoutErrors 断言响应是重定向回前个 URL，并 WITHOUT 错误。
assertRedirectContains 断言响应是重定向，并包含给定的字符串。
assertRedirectToRoute 断言响应是重定向到给定路由。
assertRedirectToSignedRoute 断言响应是重定向到给定签名路由。
assertRequestTimeout 断言响应具有请求超时（408）HTTP 状态码。
assertSee 断言响应包含给定的字符串。
assertSeeInOrder 断言响应包含给定字符串的顺序。
assertSeeText 断言响应包含给定文本。
assertSeeTextInOrder 断言响应包含给定文本的顺序。
assertServerError 断言响应具有服务器错误（500）HTTP 状态码。
assertServiceUnavailable 断言响应具有服务不可用（503）HTTP 状态码。
assertSessionHas 断言会话包含给定的键。
assertSessionHasInput 断言会话包含给定输入。
assertSessionHasAll 断言会话包含给定的键。
assertSessionHasErrors 断言会话包含给定的验证错误。
assertSessionHasErrorsIn 断言会话包含给定的验证错误。
assertSessionHasNoErrors 断言会话不包含任何验证错误。
assertSessionDoesntHaveErrors 断言会话不包含给定的验证错误。
assertSessionMissing 断言会话不包含给定的键。
assertStatus 断言响应具有给定的 HTTP 状态码。
assertSuccessful 断言响应具有成功（2xx）HTTP 状态码。
assertTooManyRequests 断言响应具有请求过多（429）HTTP 状态码。
assertUnauthorized 断言响应具有未授权（401）HTTP 状态码。
assertUnprocessable 断言响应具有不可处理的（422）HTTP 状态码。
assertUnsupportedMediaType 断言响应具有不支持的媒体类型（415）HTTP 状态码。
assertValid 断言响应的 JSON 响应内容有效。
assertInvalid 断言响应的 JSON 响应内容无效。
assertViewHas 断言视图包含给定的键。
assertViewHasAll 断言视图包含给定的键。
assertViewIs 断言响应的视图名称与给定名称匹配。
assertViewMissing 断言视图不包含给定的键。

函数详解：

assertAccepted 断言响应具有已接受（202）HTTP 状态码。
```
$response->assertAccepted();
```
assertBadRequest 断言响应具有错误请求（400）HTTP 状态码。
```
$response->assertBadRequest();
```
assertClientError 断言响应具有客户端错误（>= 400, < 500）HTTP 状态码。
```
$response->assertClientError();
```
assertConflict 断言响应具有冲突（409）HTTP 状态码。
```
$response->assertConflict();
```

assertCookie 断言响应包含给定的 cookie：

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

assertCookieExpired 断言响应包含给定的 cookie 且已过期：
```
$response->assertCookieExpired($cookieName);
```
assertCookieNotExpired 断言响应包含给定的 cookie 且未过期：
```
$response->assertCookieNotExpired($cookieName);
```
assertCookieMissing 断言响应不包含给定的 cookie：
```
$response->assertCookieMissing($cookieName);
```
assertCreated 断言响应具有 201 HTTP 状态码：
```
$response->assertCreated();
```
assertDontSee 断言响应中不包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串：
```
$response->assertDontSee($value, $escape = true);
```
assertDontSeeText 断言响应文本中不包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串。在进行断言之前，此方法会将响应内容传递给 strip_tags PHP 函数：
```
$response->assertDontSeeText($value, $escape = true);
```
assertDownload 断言响应是“下载”。通常，这意味着返回响应的被调用路由返回了 Response::download 响应、BinaryFileResponse 或 Storage::download 响应：
```
$response->assertDownload();
```
如果您愿意，可以断言可下载文件被分配了给定的文件名：
```
$response->assertDownload('image.jpg');
```
assertExactJson 断言响应包含与给定 JSON 数据完全匹配的内容：
```
$response->assertExactJson(array $data);
```
assertExactJsonStructure 断言响应包含与给定 JSON 结构完全匹配的内容：
```
$response->assertExactJsonStructure(array $data);
```
此方法是 assertJsonStructure 的更严格变体。与 assertJsonStructure 相比，如果响应包含任何未明确包含在预期 JSON 结构中的键，此方法将失败。
assertForbidden 断言响应具有禁止（403）HTTP 状态码：
```
$response->assertForbidden();
```
assertFound 断言响应具有已找到（302）HTTP 状态码：
```
$response->assertFound();
```
assertGone 断言响应具有已失效（410）HTTP 状态码：
```
$response->assertGone();
```

assertHeader 断言响应上存在给定的头和值：

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

assertHeaderMissing 断言响应上不存在给定的头：
```
$response->assertHeaderMissing($headerName);
```
assertInternalServerError 断言响应具有“内部服务器错误”（500）HTTP 状态码：
```
$response->assertInternalServerError();
```
assertJson 断言响应包含给定的 JSON 数据：
```
$response->assertJson(array $data, $strict = false);
```
assertJson 方法将响应转换为数组，以验证给定数组存在于应用程序返回的 JSON 响应中。因此，如果 JSON 响应中存在其他属性，只要给定的片段存在，此测试仍然会通过。
assertJsonCount 断言响应 JSON 在给定键处有一个具有预期项目数量的数组：
```
$response->assertJsonCount($count, $key = null);
```

assertJsonFragment 断言响应中的任何位置都包含给定的 JSON 数据：

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

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

assertJsonIsArray 断言响应 JSON 是一个数组：
```
$response->assertJsonIsArray();
```
assertJsonIsObject 断言响应 JSON 是一个对象：
```
$response->assertJsonIsObject();
```
assertJsonMissing 断言响应不包含给定的 JSON 数据：
```
$response->assertJsonMissing(array $data);
```
assertJsonMissingExact 断言响应不包含精确的 JSON 数据：
```
$response->assertJsonMissingExact(array $data);
```
assertJsonMissingValidationErrors 断言响应对于给定的键没有 JSON 验证错误：
```
$response->assertJsonMissingValidationErrors($keys);
```
更通用的 assertValid 方法可用于断言响应没有作为 JSON 返回的验证错误，并且没有错误被闪存到会话存储中。
assertJsonPath 断言响应在指定的路径上包含给定的数据：
```
$response->assertJsonPath($path, $expectedValue);
```
例如，如果您的应用程序返回以下 JSON 响应：
```
{
    "user": {
        "name": "Steve Schoger"
    }
}
```
您可以像这样断言 user 对象的 name 属性匹配给定值：
```
$response->assertJsonPath('user.name', 'Steve Schoger');
```
assertJsonMissingPath 断言响应不包含给定的路径：
```
$response->assertJsonMissingPath($path);
```
例如，如果您的应用程序返回以下 JSON 响应：
```
{
    "user": {
        "name": "Steve Schoger"
    }
}
```
您可以断言它不包含 user 对象的 email 属性：
```
$response->assertJsonMissingPath('user.email');
```

assertJsonStructure 断言响应具有给定的 JSON 结构：

$response->assertJsonStructure(array $structure);

例如，如果您的应用程序返回的 JSON 响应包含以下数据：

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

您可以像这样断言 JSON 结构符合您的预期：

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

有时，您的应用程序返回的 JSON 响应可能包含对象数组：

{
    "user": [
        {
            "name": "Steve Schoger",
            "age": 55,
            "location": "Earth"
        },
        {
            "name": "Mary Schoger",
            "age": 60,
            "location": "Earth"
        }
    ]
}

在这种情况下，您可以使用 * 字符来对数组中所有对象的结构进行断言：

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

assertJsonValidationErrors 断言响应对于给定的键具有 JSON 验证错误。当对验证错误作为 JSON 结构返回而不是闪存到会话的响应进行断言时，应使用此方法：
```
$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');
```
更通用的 assertInvalid 方法可用于断言响应具有作为 JSON 返回的验证错误，或者错误被闪存到会话存储中。
assertJsonValidationErrorFor 断言响应对于给定的键具有任何 JSON 验证错误：
```
$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');
```
assertMethodNotAllowed 断言响应具有方法不允许（405）HTTP 状态码：
```
$response->assertMethodNotAllowed();
```
assertMovedPermanently 断言响应具有永久移动（301）HTTP 状态码：
```
$response->assertMovedPermanently();
```
assertLocation 断言响应在 Location 头中具有给定的 URI 值：
```
$response->assertLocation($uri);
```
assertContent 断言给定字符串与响应内容匹配：
```
$response->assertContent($value);
```
assertNoContent 断言响应具有给定的 HTTP 状态码且没有内容：
```
$response->assertNoContent($status = 204);
```
assertStreamed 断言响应是流式响应：
```
$response->assertStreamed();
```
assertStreamedContent 断言给定字符串与流式响应内容匹配：
```
$response->assertStreamedContent($value);
```
assertNotFound 断言响应具有未找到（404）HTTP 状态码：
```
$response->assertNotFound();
```
assertOk 断言响应具有 200 HTTP 状态码：
```
$response->assertOk();
```
assertPaymentRequired 断言响应具有需要付款（402）HTTP 状态码：
```
$response->assertPaymentRequired();
```
assertPlainCookie 断言响应包含给定的未加密 cookie：
```
$response->assertPlainCookie($cookieName, $value = null);
```
assertRedirect 断言响应重定向到给定的 URI：
```
$response->assertRedirect($uri = null);
```
assertRedirectBack 断言响应是否正在重定向回上一页：
```
$response->assertRedirectBack();
```

assertRedirectBackWithErrors 断言响应是否正在重定向回上一页并且会话具有给定的错误：

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

assertRedirectBackWithoutErrors 断言响应是否正在重定向回上一页并且会话不包含任何错误消息：
```
$response->assertRedirectBackWithoutErrors();
```
assertRedirectContains 断言响应是否重定向到包含给定字符串的 URI：
```
$response->assertRedirectContains($string);
```
assertRedirectToRoute 断言响应重定向到给定的命名路由：
```
$response->assertRedirectToRoute($name, $parameters = []);
```

assertRedirectToSignedRoute 断言响应重定向到给定的签名路由：

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

assertRequestTimeout 断言响应具有请求超时（408）HTTP 状态码：
```
$response->assertRequestTimeout();
```
assertSee 断言响应中包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串：
```
$response->assertSee($value, $escape = true);
```
assertSeeInOrder 断言响应中按顺序包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串：
```
$response->assertSeeInOrder(array $values, $escape = true);
```
assertSeeText 断言响应文本中包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串。在进行断言之前，响应内容将传递给 strip_tags PHP 函数：
```
$response->assertSeeText($value, $escape = true);
```
assertSeeTextInOrder 断言响应文本中按顺序包含给定字符串。除非您传递第二个参数 false，否则此断言将自动转义给定字符串。在进行断言之前，响应内容将传递给 strip_tags PHP 函数：
```
$response->assertSeeTextInOrder(array $values, $escape = true);
```
assertServerError 断言响应具有服务器错误（>= 500 , < 600）HTTP 状态码：
```
$response->assertServerError();
```
assertServiceUnavailable 断言响应具有“服务不可用”（503）HTTP 状态码：
```
$response->assertServiceUnavailable();
```
assertSessionHas 断言会话包含给定的数据：
```
$response->assertSessionHas($key, $value = null);
```
如果需要，可以提供一个闭包作为 assertSessionHas 方法的第二个参数。如果闭包返回 true，则断言将通过：
```
$response->assertSessionHas($key, function (User $value) {
    return $value->name === 'Taylor Otwell';
});
```

assertSessionHasInput 断言会话在闪存输入数组中具有给定值：

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

如果需要，可以提供一个闭包作为 assertSessionHasInput 方法的第二个参数。如果闭包返回 true，则断言将通过：

use Illuminate\Support\Facades\Crypt;

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

assertSessionHasAll 断言会话包含给定的键/值对数组：
```
$response->assertSessionHasAll(array $data);
```
例如，如果您的应用程序的会话包含 name 和 status 键，您可以像这样断言它们都存在并具有指定的值：
```
$response->assertSessionHasAll([
    'name' => 'Taylor Otwell',
    'status' => 'active',
]);
```
assertSessionHasErrors 断言会话包含给定 $keys 的错误。如果 $keys 是关联数组，则断言会话包含每个字段（键）的特定错误消息（值）。在测试将验证错误闪存到会话而不是将其作为 JSON 结构返回的路由时，应使用此方法：
```
$response->assertSessionHasErrors(
    array $keys = [], $format = null, $errorBag = 'default'
);
```
例如，要断言 name 和 email 字段具有被闪存到会话的验证错误消息，您可以像这样调用 assertSessionHasErrors 方法：
```
$response->assertSessionHasErrors(['name', 'email']);
```
或者，您可以断言给定字段具有特定的验证错误消息：
```
$response->assertSessionHasErrors([
    'name' => 'The given name was invalid.'
]);
```
更通用的 assertInvalid 方法可用于断言响应具有作为 JSON 返回的验证错误，或者错误被闪存到会话存储中。
assertSessionHasErrorsIn 断言会话在特定的错误包中包含给定 $keys 的错误。如果 $keys 是关联数组，则断言会话在错误包中包含每个字段（键）的特定错误消息（值）：
```
$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);
```
assertSessionHasNoErrors 断言会话没有验证错误：
```
$response->assertSessionHasNoErrors();
```
assertSessionDoesntHaveErrors 断言会话对于给定的键没有验证错误：
```
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');
```
更通用的 assertValid 方法可用于断言响应没有作为 JSON 返回的验证错误，并且没有错误被闪存到会话存储中。
assertSessionMissing 断言会话不包含给定的键：
```
$response->assertSessionMissing($key);
```
assertStatus 断言响应具有给定的 HTTP 状态码：
```
$response->assertStatus($code);
```
assertSuccessful 断言响应具有成功（>= 200 和 < 300）HTTP 状态码：
```
$response->assertSuccessful();
```
assertTooManyRequests 断言响应具有请求过多（429）HTTP 状态码：
```
$response->assertTooManyRequests();
```
assertUnauthorized 断言响应具有未授权（401）HTTP 状态码：
```
$response->assertUnauthorized();
```
assertUnprocessable 断言响应具有不可处理实体（422）HTTP 状态码：
```
$response->assertUnprocessable();
```
assertUnsupportedMediaType 断言响应具有不支持的媒体类型（415）HTTP 状态码：
```
$response->assertUnsupportedMediaType();
```
assertValid 断言响应对于给定的键没有验证错误。此方法可用于对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言：
```
// 断言没有验证错误...
$response->assertValid();

// 断言给定的键没有验证错误...
$response->assertValid(['name', 'email']);
```
assertInvalid 断言响应对于给定的键具有验证错误。此方法可用于对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言：
```
$response->assertInvalid(['name', 'email']);
```
您还可以断言给定键具有特定的验证错误消息。这样做时，您可以提供完整的消息或只提供消息的一小部分：
```
$response->assertInvalid([
    'name' => 'The name field is required.',
    'email' => 'valid email address',
]);
```
如果您想断言给定的字段是唯一具有验证错误的字段，您可以使用 assertOnlyInvalid 方法：
```
$response->assertOnlyInvalid(['name', 'email']);
```
assertViewHas 断言响应视图包含给定的数据：
```
$response->assertViewHas($key, $value = null);
```
将闭包作为第二个参数传递给 assertViewHas 方法将允许您检查并对特定视图数据进行断言：
```
$response->assertViewHas('user', function (User $user) {
    return $user->name === 'Taylor';
});
```
此外，视图数据可以作为响应上的数组变量进行访问，让您可以方便地检查它：
```
expect($response['name'])->toBe('Taylor');
```

assertViewHasAll 断言响应视图具有给定的数据列表：

$response->assertViewHasAll(array $data);

此方法可用于断言视图仅包含与给定键匹配的数据：

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

或者，您可以断言视图数据存在并具有特定值：

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

assertViewIs 断言路由返回了给定的视图：
```
$response->assertViewIs($value);
```
assertViewMissing 断言给定的数据键未提供给应用程序响应中返回的视图：
```
$response->assertViewMissing($key);
```

认证断言

Laravel 还提供了各种与认证相关的断言，您可以在应用程序的功能测试中使用。请注意，这些方法是在测试类本身上调用的，而不是在 get 和 post 等方法返回的 Illuminate\Testing\TestResponse 实例上调用的。

assertAuthenticated 断言用户已认证：

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

assertGuest 断言用户未认证：
```
$this->assertGuest($guard = null);
```

assertAuthenticatedAs 断言特定用户已认证：

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

验证断言

Laravel 提供了两个主要的验证相关断言，您可以使用它们来确保请求中提供的数据是有效或无效的。

assertValid 断言响应对于给定的键没有验证错误。此方法可用于对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言：
```
// 断言没有验证错误...
$response->assertValid();

// 断言给定的键没有验证错误...
$response->assertValid(['name', 'email']);
```
assertInvalid 断言响应对于给定的键具有验证错误。此方法可用于对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言：
```
$response->assertInvalid(['name', 'email']);
```
您还可以断言给定键具有特定的验证错误消息。这样做时，您可以提供完整的消息或只提供消息的一小部分：
```
$response->assertInvalid([
    'name' => 'The name field is required.',
    'email' => 'valid email address',
]);
```

快速入门

控制台测试