HTTP 测试

简介
发出请求
测试 JSON API
- 流畅的 JSON 测试
测试文件上传
测试视图
- 渲染 Blade 和组件
可用断言

简介

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

1<?php
2 
3test('the application returns a successful response', function () {
4    $response = $this->get('/');
5 
6    $response->assertStatus(200);
7});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic test example.
11     */
12    public function test_the_application_returns_a_successful_response(): void
13    {
14        $response = $this->get('/');
15 
16        $response->assertStatus(200);
17    }
18}

<?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 的实例，后者提供了一系列有用的断言，允许您检查应用程序的响应

1<?php
2 
3test('basic request', function () {
4    $response = $this->get('/');
5 
6    $response->assertStatus(200);
7});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic test example.
11     */
12    public function test_a_basic_request(): void
13    {
14        $response = $this->get('/');
15 
16        $response->assertStatus(200);
17    }
18}

<?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 方法在将请求发送到应用程序之前自定义请求的标头。此方法允许您向请求添加任何自定义标头

1<?php
2 
3test('interacting with headers', function () {
4    $response = $this->withHeaders([
5        'X-Header' => 'Value',
6    ])->post('/user', ['name' => 'Sally']);
7 
8    $response->assertStatus(201);
9});

<?php

test('interacting with headers', function () {
    $response = $this->withHeaders([
        'X-Header' => 'Value',
    ])->post('/user', ['name' => 'Sally']);

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic functional test example.
11     */
12    public function test_interacting_with_headers(): void
13    {
14        $response = $this->withHeaders([
15            'X-Header' => 'Value',
16        ])->post('/user', ['name' => 'Sally']);
17 
18        $response->assertStatus(201);
19    }
20}

<?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 方法接受名称/值对的数组

 1<?php
 2 
 3test('interacting with cookies', function () {
 4    $response = $this->withCookie('color', 'blue')->get('/');
 5 
 6    $response = $this->withCookies([
 7        'color' => 'blue',
 8        'name' => 'Taylor',
 9    ])->get('/');
10 
11    //
12});

<?php

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

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

    //
});

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    public function test_interacting_with_cookies(): void
10    {
11        $response = $this->withCookie('color', 'blue')->get('/');
12 
13        $response = $this->withCookies([
14            'color' => 'blue',
15            'name' => 'Taylor',
16        ])->get('/');
17 
18        //
19    }
20}

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

        //
    }
}

Session / 身份验证

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

1<?php
2 
3test('interacting with the session', function () {
4    $response = $this->withSession(['banned' => false])->get('/');
5 
6    //
7});

<?php

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

    //
});

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    public function test_interacting_with_the_session(): void
10    {
11        $response = $this->withSession(['banned' => false])->get('/');
12 
13        //
14    }
15}

<?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 助手方法提供了一种简单的方法来验证给定用户作为当前用户。例如，我们可以使用模型工厂来生成和验证用户

 1<?php
 2 
 3use App\Models\User;
 4 
 5test('an action that requires authentication', function () {
 6    $user = User::factory()->create();
 7 
 8    $response = $this->actingAs($user)
 9        ->withSession(['banned' => false])
10        ->get('/');
11 
12    //
13});

<?php

use App\Models\User;

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

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

    //
});

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use App\Models\User;
 6use Tests\TestCase;
 7 
 8class ExampleTest extends TestCase
 9{
10    public function test_an_action_that_requires_authentication(): void
11    {
12        $user = User::factory()->create();
13 
14        $response = $this->actingAs($user)
15            ->withSession(['banned' => false])
16            ->get('/');
17 
18        //
19    }
20}

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

        //
    }
}

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

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

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

调试响应

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

 1<?php
 2 
 3test('basic test', function () {
 4    $response = $this->get('/');
 5 
 6    $response->dumpHeaders();
 7 
 8    $response->dumpSession();
 9 
10    $response->dump();
11});

<?php

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

    $response->dumpHeaders();

    $response->dumpSession();

    $response->dump();
});

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic test example.
11     */
12    public function test_basic_test(): void
13    {
14        $response = $this->get('/');
15 
16        $response->dumpHeaders();
17 
18        $response->dumpSession();
19 
20        $response->dump();
21    }
22}

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

        $response->dumpSession();

        $response->dump();
    }
}

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

 1<?php
 2 
 3test('basic test', function () {
 4    $response = $this->get('/');
 5 
 6    $response->ddHeaders();
 7    $response->ddSession();
 8    $response->ddJson();
 9    $response->dd();
10});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic test example.
11     */
12    public function test_basic_test(): void
13    {
14        $response = $this->get('/');
15 
16        $response->ddHeaders();
17 
18        $response->ddSession();
19 
20        $response->dd();
21    }
22}

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

        $response->ddSession();

        $response->dd();
    }
}

异常处理

有时您可能需要测试您的应用程序是否抛出特定的异常。要实现这一点，您可以通过 Exceptions 外观模式“伪造”异常处理程序。一旦异常处理程序被伪造，您可以使用 assertReported 和 assertNotReported 方法来断言在请求期间抛出的异常

 1<?php
 2 
 3use App\Exceptions\InvalidOrderException;
 4use Illuminate\Support\Facades\Exceptions;
 5 
 6test('exception is thrown', function () {
 7    Exceptions::fake();
 8 
 9    $response = $this->get('/order/1');
10 
11    // Assert an exception was thrown...
12    Exceptions::assertReported(InvalidOrderException::class);
13 
14    // Assert against the exception...
15    Exceptions::assertReported(function (InvalidOrderException $e) {
16        return $e->getMessage() === 'The order was invalid.';
17    });
18});

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use App\Exceptions\InvalidOrderException;
 6use Illuminate\Support\Facades\Exceptions;
 7use Tests\TestCase;
 8 
 9class ExampleTest extends TestCase
10{
11    /**
12     * A basic test example.
13     */
14    public function test_exception_is_thrown(): void
15    {
16        Exceptions::fake();
17 
18        $response = $this->get('/');
19 
20        // Assert an exception was thrown...
21        Exceptions::assertReported(InvalidOrderException::class);
22 
23        // Assert against the exception...
24        Exceptions::assertReported(function (InvalidOrderException $e) {
25            return $e->getMessage() === 'The order was invalid.';
26        });
27    }
28}

<?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 方法可用于断言在请求期间未抛出给定的异常，或者未抛出任何异常

1Exceptions::assertNotReported(InvalidOrderException::class);
2 
3Exceptions::assertNothingReported();

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

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

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

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

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

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

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

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

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

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

如果您想检查并针对抛出的异常进行断言，您可以提供一个闭包作为 assertThrows 方法的第二个参数

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

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

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

 1<?php
 2 
 3test('making an api request', function () {
 4    $response = $this->postJson('/api/user', ['name' => 'Sally']);
 5 
 6    $response
 7        ->assertStatus(201)
 8        ->assertJson([
 9            'created' => true,
10        ]);
11});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic functional test example.
11     */
12    public function test_making_an_api_request(): void
13    {
14        $response = $this->postJson('/api/user', ['name' => 'Sally']);
15 
16        $response
17            ->assertStatus(201)
18            ->assertJson([
19                'created' => true,
20            ]);
21    }
22}

<?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 响应中返回的各个值

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

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

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

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

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

断言精确 JSON 匹配

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

 1<?php
 2 
 3test('asserting an exact json match', function () {
 4    $response = $this->postJson('/user', ['name' => 'Sally']);
 5 
 6    $response
 7        ->assertStatus(201)
 8        ->assertExactJson([
 9            'created' => true,
10        ]);
11});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic functional test example.
11     */
12    public function test_asserting_an_exact_json_match(): void
13    {
14        $response = $this->postJson('/user', ['name' => 'Sally']);
15 
16        $response
17            ->assertStatus(201)
18            ->assertExactJson([
19                'created' => true,
20            ]);
21    }
22}

<?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 方法

1<?php
2 
3test('asserting a json path value', function () {
4    $response = $this->postJson('/user', ['name' => 'Sally']);
5 
6    $response
7        ->assertStatus(201)
8        ->assertJsonPath('team.owner.name', 'Darian');
9});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    /**
10     * A basic functional test example.
11     */
12    public function test_asserting_a_json_paths_value(): void
13    {
14        $response = $this->postJson('/user', ['name' => 'Sally']);
15 
16        $response
17            ->assertStatus(201)
18            ->assertJsonPath('team.owner.name', 'Darian');
19    }
20}

<?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 方法还接受一个闭包，该闭包可用于动态确定断言是否应通过

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

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

流畅的 JSON 测试

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

 1use Illuminate\Testing\Fluent\AssertableJson;
 2 
 3test('fluent json', function () {
 4    $response = $this->getJson('/users/1');
 5 
 6    $response
 7        ->assertJson(fn (AssertableJson $json) =>
 8            $json->where('id', 1)
 9                ->where('name', 'Victoria Faith')
10                ->where('email', fn (string $email) => str($email)->is('[email protected]'))
11                ->whereNot('status', 'pending')
12                ->missing('password')
13                ->etc()
14        );
15});

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('[email protected]'))
                ->whereNot('status', 'pending')
                ->missing('password')
                ->etc()
        );
});

 1use Illuminate\Testing\Fluent\AssertableJson;
 2 
 3/**
 4 * A basic functional test example.
 5 */
 6public function test_fluent_json(): void
 7{
 8    $response = $this->getJson('/users/1');
 9 
10    $response
11        ->assertJson(fn (AssertableJson $json) =>
12            $json->where('id', 1)
13                ->where('name', 'Victoria Faith')
14                ->where('email', fn (string $email) => str($email)->is('[email protected]'))
15                ->whereNot('status', 'pending')
16                ->missing('password')
17                ->etc()
18        );
19}

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('[email protected]'))
                ->whereNot('status', 'pending')
                ->missing('password')
                ->etc()
        );
}

理解 `etc` 方法

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

此行为背后的意图是通过强制您显式地针对属性进行断言或通过 etc 方法显式允许其他属性，来保护您免于意外地在 JSON 响应中暴露敏感信息。

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

断言属性存在/不存在

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

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

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

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

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

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

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

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

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

针对 JSON 集合进行断言

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

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

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

在这些情况下，我们可以使用流畅的 JSON 对象的 has 方法来针对响应中包含的用户进行断言。例如，让我们断言 JSON 响应包含三个用户。接下来，我们将使用 first 方法对集合中的第一个用户进行一些断言。first 方法接受一个闭包，该闭包接收另一个可断言的 JSON 字符串，我们可以使用该字符串对 JSON 集合中的第一个对象进行断言

 1$response
 2    ->assertJson(fn (AssertableJson $json) =>
 3        $json->has(3)
 4            ->first(fn (AssertableJson $json) =>
 5                $json->where('id', 1)
 6                    ->where('name', 'Victoria Faith')
 7                    ->where('email', fn (string $email) => str($email)->is('[email protected]'))
 8                    ->missing('password')
 9                    ->etc()
10            )
11    );

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

作用域 JSON 集合断言

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

1Route::get('/users', function () {
2    return [
3        'meta' => [...],
4        'users' => User::all(),
5    ];
6})

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

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

 1$response
 2    ->assertJson(fn (AssertableJson $json) =>
 3        $json->has('meta')
 4            ->has('users', 3)
 5            ->has('users.0', fn (AssertableJson $json) =>
 6                $json->where('id', 1)
 7                    ->where('name', 'Victoria Faith')
 8                    ->where('email', fn (string $email) => str($email)->is('[email protected]'))
 9                    ->missing('password')
10                    ->etc()
11            )
12    );

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

但是，您无需两次调用 has 方法来断言 users 集合，而是可以进行一次调用，该调用将闭包作为其第三个参数提供。这样做时，将自动调用闭包并将其作用域限定为集合中的第一个项目

 1$response
 2    ->assertJson(fn (AssertableJson $json) =>
 3        $json->has('meta')
 4            ->has('users', 3, fn (AssertableJson $json) =>
 5                $json->where('id', 1)
 6                    ->where('name', 'Victoria Faith')
 7                    ->where('email', fn (string $email) => str($email)->is('[email protected]'))
 8                    ->missing('password')
 9                    ->etc()
10            )
11    );

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

断言 JSON 类型

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

1$response->assertJson(fn (AssertableJson $json) =>
2    $json->whereType('id', 'integer')
3        ->whereAllType([
4            'users.0.name' => 'string',
5            'meta' => 'array'
6        ])
7);

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

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

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

$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 外观模式的 fake 方法结合使用，大大简化了文件上传的测试。例如，您可以结合使用这两个功能来轻松测试头像上传表单

 1<?php
 2 
 3use Illuminate\Http\UploadedFile;
 4use Illuminate\Support\Facades\Storage;
 5 
 6test('avatars can be uploaded', function () {
 7    Storage::fake('avatars');
 8 
 9    $file = UploadedFile::fake()->image('avatar.jpg');
10 
11    $response = $this->post('/avatar', [
12        'avatar' => $file,
13    ]);
14 
15    Storage::disk('avatars')->assertExists($file->hashName());
16});

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Illuminate\Http\UploadedFile;
 6use Illuminate\Support\Facades\Storage;
 7use Tests\TestCase;
 8 
 9class ExampleTest extends TestCase
10{
11    public function test_avatars_can_be_uploaded(): void
12    {
13        Storage::fake('avatars');
14 
15        $file = UploadedFile::fake()->image('avatar.jpg');
16 
17        $response = $this->post('/avatar', [
18            'avatar' => $file,
19        ]);
20 
21        Storage::disk('avatars')->assertExists($file->hashName());
22    }
23}

<?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 外观模式提供的 assertMissing 方法

1Storage::fake('avatars');
2 
3// ...
4 
5Storage::disk('avatars')->assertMissing('missing.jpg');

Storage::fake('avatars');

// ...

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

伪造文件自定义

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

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

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

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

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

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

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

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

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

测试视图

Laravel 还允许您渲染视图，而无需向应用程序发出模拟的 HTTP 请求。要实现这一点，您可以在测试中调用 view 方法。view 方法接受视图名称和可选的数据数组。该方法返回 Illuminate\Testing\TestView 的实例，后者提供了几种方便的方法来断言视图的内容

1<?php
2 
3test('a welcome view can be rendered', function () {
4    $view = $this->view('welcome', ['name' => 'Taylor']);
5 
6    $view->assertSee('Taylor');
7});

<?php

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

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

 1<?php
 2 
 3namespace Tests\Feature;
 4 
 5use Tests\TestCase;
 6 
 7class ExampleTest extends TestCase
 8{
 9    public function test_a_welcome_view_can_be_rendered(): void
10    {
11        $view = $this->view('welcome', ['name' => 'Taylor']);
12 
13        $view->assertSee('Taylor');
14    }
15}

<?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 实例转换为字符串来获取原始渲染的视图内容

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

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

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

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

$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 的实例

1$view = $this->blade(
2    '<x-component :name="$name" />',
3    ['name' => 'Taylor']
4);
5 
6$view->assertSee('Taylor');

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

$view->assertSee('Taylor');

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

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

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

$view->assertSee('Taylor');

可用断言

响应断言

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

assertAccepted assertBadRequest assertConflict assertCookie assertCookieExpired assertCookieNotExpired assertCookieMissing assertCreated assertDontSee assertDontSeeText assertDownload assertExactJson assertExactJsonStructure 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

断言响应具有错误的请求 (400) HTTP 状态代码

1$response->assertBadRequest();

$response->assertBadRequest();

assertAccepted

断言响应具有已接受 (202) HTTP 状态代码

1$response->assertAccepted();

$response->assertAccepted();

assertConflict

断言响应具有冲突 (409) HTTP 状态代码

1$response->assertConflict();

$response->assertConflict();

断言响应包含给定的 Cookie

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

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

断言响应包含给定的 Cookie 且已过期

1$response->assertCookieExpired($cookieName);

$response->assertCookieExpired($cookieName);

断言响应包含给定的 Cookie 且未过期

1$response->assertCookieNotExpired($cookieName);

$response->assertCookieNotExpired($cookieName);

断言响应不包含给定的 Cookie

1$response->assertCookieMissing($cookieName);

$response->assertCookieMissing($cookieName);

assertCreated

断言响应具有 201 HTTP 状态代码

1$response->assertCreated();

$response->assertCreated();

assertDontSee

断言应用程序返回的响应中不包含给定的字符串。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串

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

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

assertDontSeeText

断言响应文本中不包含给定的字符串。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串。此方法将在进行断言之前将响应内容传递给 strip_tags PHP 函数

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

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

assertDownload

断言响应是“下载”。通常，这意味着调用的路由返回了 Response::download 响应、BinaryFileResponse 或 Storage::download 响应

1$response->assertDownload();

$response->assertDownload();

如果您愿意，您可以断言可下载文件已被分配给定的文件名

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

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

assertExactJson

断言响应包含给定 JSON 数据的精确匹配项

1$response->assertExactJson(array $data);

$response->assertExactJson(array $data);

assertExactJsonStructure

断言响应包含给定 JSON 结构的精确匹配项

1$response->assertExactJsonStructure(array $data);

$response->assertExactJsonStructure(array $data);

此方法是 assertJsonStructure 的更严格变体。与 assertJsonStructure 相比，如果响应包含任何未在预期 JSON 结构中显式包含的键，则此方法将失败。

assertForbidden

断言响应具有禁止 (403) HTTP 状态代码

1$response->assertForbidden();

$response->assertForbidden();

assertFound

断言响应具有已找到 (302) HTTP 状态代码

1$response->assertFound();

$response->assertFound();

assertGone

断言响应具有已消失 (410) HTTP 状态代码

1$response->assertGone();

$response->assertGone();

assertHeader

断言给定标头和值存在于响应中

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

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

assertHeaderMissing

断言给定标头不存在于响应中

1$response->assertHeaderMissing($headerName);

$response->assertHeaderMissing($headerName);

assertInternalServerError

断言响应具有“内部服务器错误” (500) HTTP 状态代码

1$response->assertInternalServerError();

$response->assertInternalServerError();

assertJson

断言响应包含给定的 JSON 数据

1$response->assertJson(array $data, $strict = false);

$response->assertJson(array $data, $strict = false);

assertJsonCount

断言响应 JSON 在给定键处具有包含预期项目数的数组

1$response->assertJsonCount($count, $key = null);

$response->assertJsonCount($count, $key = null);

assertJsonFragment

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

 1Route::get('/users', function () {
 2    return [
 3        'users' => [
 4            [
 5                'name' => 'Taylor Otwell',
 6            ],
 7        ],
 8    ];
 9});
10 
11$response->assertJsonFragment(['name' => 'Taylor Otwell']);

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

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

assertJsonIsArray

断言响应 JSON 是一个数组

1$response->assertJsonIsArray();

$response->assertJsonIsArray();

assertJsonIsObject

断言响应 JSON 是一个对象

1$response->assertJsonIsObject();

$response->assertJsonIsObject();

assertJsonMissing

断言响应不包含给定的 JSON 数据

1$response->assertJsonMissing(array $data);

$response->assertJsonMissing(array $data);

assertJsonMissingExact

断言响应不包含精确的 JSON 数据

1$response->assertJsonMissingExact(array $data);

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

断言响应对于给定的键没有 JSON 验证错误

1$response->assertJsonMissingValidationErrors($keys);

$response->assertJsonMissingValidationErrors($keys);

更通用的 assertValid 方法可用于断言响应没有作为 JSON 返回的验证错误，并且没有错误被闪存到会话存储。

assertJsonPath

断言响应在指定的路径包含给定的数据

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

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

例如，如果您的应用程序返回以下 JSON 响应

1{
2    "user": {
3        "name": "Steve Schoger"
4    }
5}

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

您可以断言 user 对象的 name 属性是否与给定的值匹配，如下所示

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

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

assertJsonMissingPath

断言响应不包含给定的路径

1$response->assertJsonMissingPath($path);

$response->assertJsonMissingPath($path);

例如，如果您的应用程序返回以下 JSON 响应

1{
2    "user": {
3        "name": "Steve Schoger"
4    }
5}

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

您可以断言它不包含 user 对象的 email 属性

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

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

assertJsonStructure

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

1$response->assertJsonStructure(array $structure);

$response->assertJsonStructure(array $structure);

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

1{
2    "user": {
3        "name": "Steve Schoger"
4    }
5}

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

您可以断言 JSON 结构与您的期望匹配，如下所示

1$response->assertJsonStructure([
2    'user' => [
3        'name',
4    ]
5]);

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

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

 1{
 2    "user": [
 3        {
 4            "name": "Steve Schoger",
 5            "age": 55,
 6            "location": "Earth"
 7        },
 8        {
 9            "name": "Mary Schoger",
10            "age": 60,
11            "location": "Earth"
12        }
13    ]
14}

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

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

1$response->assertJsonStructure([
2    'user' => [
3        '*' => [
4             'name',
5             'age',
6             'location'
7        ]
8    ]
9]);

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

assertJsonValidationErrors

断言响应对于给定的键具有给定的 JSON 验证错误。当针对验证错误作为 JSON 结构返回而不是闪存到会话的响应进行断言时，应使用此方法

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

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

更通用的 assertInvalid 方法可用于断言响应具有作为 JSON 返回的验证错误，或者错误已闪存到会话存储。

assertJsonValidationErrorFor

断言响应对于给定的键具有任何 JSON 验证错误

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

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

assertMethodNotAllowed

断言响应具有方法不允许 (405) HTTP 状态代码

1$response->assertMethodNotAllowed();

$response->assertMethodNotAllowed();

assertMovedPermanently

断言响应具有永久移动 (301) HTTP 状态代码

1$response->assertMovedPermanently();

$response->assertMovedPermanently();

assertLocation

断言响应在 Location 标头中具有给定的 URI 值

1$response->assertLocation($uri);

$response->assertLocation($uri);

assertContent

断言给定的字符串与响应内容匹配

1$response->assertContent($value);

$response->assertContent($value);

assertNoContent

断言响应具有给定的 HTTP 状态代码且没有内容

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

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

assertStreamedContent

断言给定的字符串与流式响应内容匹配

1$response->assertStreamedContent($value);

$response->assertStreamedContent($value);

assertNotFound

断言响应具有未找到 (404) HTTP 状态代码

1$response->assertNotFound();

$response->assertNotFound();

assertOk

断言响应具有 200 HTTP 状态代码

1$response->assertOk();

$response->assertOk();

assertPaymentRequired

断言响应具有需要付款 (402) HTTP 状态代码

1$response->assertPaymentRequired();

$response->assertPaymentRequired();

断言响应包含给定的未加密 Cookie

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

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

assertRedirect

断言响应是重定向到给定的 URI

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

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

assertRedirectContains

断言响应是否重定向到包含给定字符串的 URI

1$response->assertRedirectContains($string);

$response->assertRedirectContains($string);

assertRedirectToRoute

断言响应是重定向到给定的命名路由

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

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

assertRedirectToSignedRoute

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

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

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

assertRequestTimeout

断言响应具有请求超时 (408) HTTP 状态代码

1$response->assertRequestTimeout();

$response->assertRequestTimeout();

assertSee

断言响应中包含给定的字符串。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串

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

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

assertSeeInOrder

断言给定的字符串按顺序包含在响应中。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串

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

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

assertSeeText

断言响应文本中包含给定的字符串。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串。响应内容将在进行断言之前传递给 strip_tags PHP 函数

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

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

assertSeeTextInOrder

断言给定的字符串按顺序包含在响应文本中。除非您传递第二个参数 false，否则此断言将自动转义给定的字符串。响应内容将在进行断言之前传递给 strip_tags PHP 函数

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

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

assertServerError

断言响应具有服务器错误 (>= 500 , < 600) HTTP 状态代码

1$response->assertServerError();

$response->assertServerError();

assertServiceUnavailable

断言响应具有“服务不可用” (503) HTTP 状态代码

1$response->assertServiceUnavailable();

$response->assertServiceUnavailable();

assertSessionHas

断言会话包含给定的数据片段

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

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

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

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

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

assertSessionHasInput

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

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

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

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

1use Illuminate\Support\Facades\Crypt;
2 
3$response->assertSessionHasInput($key, function (string $value) {
4    return Crypt::decryptString($value) === 'secret';
5});

use Illuminate\Support\Facades\Crypt;

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

assertSessionHasAll

断言会话包含给定的键/值对数组

1$response->assertSessionHasAll(array $data);

$response->assertSessionHasAll(array $data);

例如，如果您的应用程序的会话包含 name 和 status 键，您可以断言这两个键都存在并具有指定的值，如下所示

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

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

assertSessionHasErrors

断言会话包含给定 $keys 的错误。如果 $keys 是关联数组，则断言会话为每个字段（键）包含特定的错误消息（值）。当测试将验证错误闪存到会话而不是将其作为 JSON 结构返回的路由时，应使用此方法

1$response->assertSessionHasErrors(
2    array $keys = [], $format = null, $errorBag = 'default'
3);

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

例如，要断言 name 和 email 字段具有已闪存到会话的验证错误消息，您可以调用 assertSessionHasErrors 方法，如下所示

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

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

或者，您可以断言给定字段具有特定的验证错误消息

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

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

更通用的 assertInvalid 方法可用于断言响应具有作为 JSON 返回的验证错误，或者错误已闪存到会话存储。

assertSessionHasErrorsIn

断言会话在特定的错误包中包含给定 $keys 的错误。如果 $keys 是关联数组，则断言会话在错误包中为每个字段（键）包含特定的错误消息（值）

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

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

assertSessionHasNoErrors

断言会话没有验证错误

1$response->assertSessionHasNoErrors();

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

断言会话对于给定的键没有验证错误

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

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

更通用的 assertValid 方法可用于断言响应没有作为 JSON 返回的验证错误，并且没有错误被闪存到会话存储。

assertSessionMissing

断言会话不包含给定的键

1$response->assertSessionMissing($key);

$response->assertSessionMissing($key);

assertStatus

断言响应具有给定的 HTTP 状态代码

1$response->assertStatus($code);

$response->assertStatus($code);

assertSuccessful

断言响应具有成功的 (>= 200 且 < 300) HTTP 状态代码

1$response->assertSuccessful();

$response->assertSuccessful();

assertTooManyRequests

断言响应具有过多请求 (429) HTTP 状态代码

1$response->assertTooManyRequests();

$response->assertTooManyRequests();

assertUnauthorized

断言响应具有未经授权 (401) HTTP 状态代码

1$response->assertUnauthorized();

$response->assertUnauthorized();

assertUnprocessable

断言响应具有无法处理的实体 (422) HTTP 状态代码

1$response->assertUnprocessable();

$response->assertUnprocessable();

assertUnsupportedMediaType

断言响应具有不支持的媒体类型 (415) HTTP 状态代码

1$response->assertUnsupportedMediaType();

$response->assertUnsupportedMediaType();

assertValid

断言响应对于给定的键没有验证错误。此方法可用于针对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言

1// Assert that no validation errors are present...
2$response->assertValid();
3 
4// Assert that the given keys do not have validation errors...
5$response->assertValid(['name', 'email']);

// Assert that no validation errors are present...
$response->assertValid();

// Assert that the given keys do not have validation errors...
$response->assertValid(['name', 'email']);

assertInvalid

断言响应对于给定的键存在验证错误。此方法可用于断言验证错误作为 JSON 结构返回的响应，或验证错误已闪存到会话的响应

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

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

您还可以断言给定的键具有特定的验证错误消息。这样做时，您可以提供完整的消息或仅消息的一小部分

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

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

assertViewHas

断言响应视图包含给定的数据片段

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

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

将闭包作为 assertViewHas 方法的第二个参数传递，将允许您检查并对特定的视图数据片段进行断言

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

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

此外，视图数据可以作为响应上的数组变量访问，允许您方便地检查它

1expect($response['name'])->toBe('Taylor');

expect($response['name'])->toBe('Taylor');

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

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

assertViewHasAll

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

1$response->assertViewHasAll(array $data);

$response->assertViewHasAll(array $data);

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

1$response->assertViewHasAll([
2    'name',
3    'email',
4]);

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

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

1$response->assertViewHasAll([
2    'name' => 'Taylor Otwell',
3    'email' => '[email protected],',
4]);

$response->assertViewHasAll([
    'name' => 'Taylor Otwell',
    'email' => '[email protected],',
]);

assertViewIs

断言给定的视图由路由返回

1$response->assertViewIs($value);

$response->assertViewIs($value);

assertViewMissing

断言给定的数据键在应用程序响应中返回的视图中不可用

1$response->assertViewMissing($key);

$response->assertViewMissing($key);

身份验证断言

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

assertAuthenticated

断言用户已通过身份验证

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

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

assertGuest

断言用户未通过身份验证

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

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

assertAuthenticatedAs

断言特定用户已通过身份验证

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

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

验证断言

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

assertValid

断言响应对于给定的键没有验证错误。此方法可用于针对验证错误作为 JSON 结构返回或验证错误已闪存到会话的响应进行断言

1// Assert that no validation errors are present...
2$response->assertValid();
3 
4// Assert that the given keys do not have validation errors...
5$response->assertValid(['name', 'email']);

// Assert that no validation errors are present...
$response->assertValid();

// Assert that the given keys do not have validation errors...
$response->assertValid(['name', 'email']);

assertInvalid

断言响应对于给定的键存在验证错误。此方法可用于断言验证错误作为 JSON 结构返回的响应，或验证错误已闪存到会话的响应

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

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

您还可以断言给定的键具有特定的验证错误消息。这样做时，您可以提供完整的消息或仅消息的一小部分

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

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

序言

开始入门

架构概念

基础知识

深入挖掘

安全

数据库

Eloquent ORM

测试

扩展包

HTTP 测试

理解 etc 方法

产品

扩展包

资源

理解 `etc` 方法