Laravel 11.x HTTPテスト

イントロダクションIntroduction

Laravelは、アプリケーションにHTTPリクエストを送信し、レスポンスを調べるためにスムーズに扱えるAPIを提供しています。例として、以下に定義している機能テストをご覧ください。Laravel provides a very fluent API for making HTTP requests to your application and examining the responses. For example, take a look at the feature test defined below:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本のテスト例
     */
    public function test_the_application_returns_a_successful_response(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

getメソッドはアプリケーションにGETリクエストを送信し、assertStatusメソッドは返えされたレスポンスに指定するHTTPステータスコードが必要であることを宣言しています。この単純なアサートに加え、Laravelはレスポンスヘッダ、コンテンツ、JSON構造などを検査するためにさまざまなアサートも用意しています。The get method makes a GET request into the application, while the assertStatus method asserts that the returned response should have the given HTTP status code. In addition to this simple assertion, Laravel also contains a variety of assertions for inspecting the response headers, content, JSON structure, and more.

リクエストの作成Making Requests

アプリケーションにリクエストを送信するには、テスト内でget、post、put、patch、deleteメソッドを呼び出してください。これらのメソッドは、実際にはアプリケーションへ「本当の」HTTPリクエストを発行しません。代わりに、ネットワークリクエスト全体が内部でシミュレートされます。To make a request to your application, you may invoke the get, post, put, patch, or delete methods within your test. These methods do not actually issue a "real" HTTP request to your application. Instead, the entire network request is simulated internally.

テストリクエストメソッドは、Illuminate\Http\Responseインスタンスを返す代わりに、Illuminate\Testing\TestResponseのインスタンスを返します。これは、アプリケーションのレスポンスの検査を可能にするさまざまな有用なアサートを提供します。Instead of returning an Illuminate\Http\Response instance, test request methods return an instance of Illuminate\Testing\TestResponse, which provides a variety of helpful assertions[#available-assertions] that allow you to inspect your application's responses:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本のテスト例
     */
    public function test_a_basic_request(): void
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

通常、各テストはアプリケーションに対して 1 つのリクエストしか行わないようにしてください。１つのテストメソッドの中で複数のリクエストを実行すると、 予期せぬ動作が起きる可能性があります。In general, each of your tests should only make one request to your application. Unexpected behavior may occur if multiple requests are executed within a single test method.

lightbulb Note: 利便性を良くするため、テストの実行時にCSRFミドルウェアを自動で無効にします。[!NOTE]
For convenience, the CSRF middleware is automatically disabled when running tests.

リクエストヘッダのカスタマイズCustomizing Request Headers

withHeadersメソッドを使用して、アプリケーションに送信する前にリクエストのヘッダをカスタマイズできます。このメソッドを使用すると、リクエストに必要なカスタムヘッダを追加できます。You may use the withHeaders method to customize the request's headers before it is sent to the application. This method allows you to add any custom headers you would like to the request:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本的な機能テストの例
     */
    public function test_interacting_with_headers(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);

        $response->assertStatus(201);
    }
}

クッキーCookies

リクエストを行う前に、withCookieまたはwithCookiesメソッドを使用してクッキー値を設定できます。withCookieメソッドは２つの引数としてCookieの名前と値を引数に取りますが、withCookiesメソッドは名前／値ペアの配列を引数に取ります。You may use the withCookie or withCookies methods to set cookie values before making a request. The withCookie method accepts a cookie name and value as its two arguments, while the withCookies method accepts an array of name / value pairs:

Pest

<?php

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

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

    //
});

PHPUnit

<?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 / Authentication

Laravelは、HTTPテスト中にセッションを操作するために、ヘルパをいくつか提供しています。まず、withSessionメソッドへ配列を渡し、セッションデータを設定できます。これは、アプリケーションにリクエストを発行する前に、セッションにデータをロードする場合に役立ちます。Laravel provides several helpers for interacting with the session during HTTP testing. First, you may set the session data to a given array using the withSession method. This is useful for loading the session with data before issuing a request to your application:

Pest

<?php

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

    //
});

PHPUnit

<?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ヘルパメソッドは、指定ユーザーを現在のユーザーとして認証する簡単な方法を提供します。たとえば、モデルファクトリを使用して、ユーザーを生成および認証できます。Laravel's session is typically used to maintain state for the currently authenticated user. Therefore, the actingAs helper method provides a simple way to authenticate a given user as the current user. For example, we may use a model factory[/docs/{{version}}/eloquent-factories] to generate and authenticate a user:

Pest

<?php

use App\Models\User;

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

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

    //
});

PHPUnit

<?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メソッドに指定したガードは、テストの間、デフォルトのガードにもなります。You may also specify which guard should be used to authenticate the given user by passing the guard name as the second argument to the actingAs method. The guard that is provided to the actingAs method will also become the default guard for the duration of the test:

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

レスポンスのデバッグDebugging Responses

アプリケーションにテストリクエストを送ったあとは、dump、dumpHeaders、dumpSessionメソッドを使用して、レスポンスの内容を調べてデバッグできます。After making a test request to your application, the dump, dumpHeaders, and dumpSession methods may be used to examine and debug the response contents:

Pest

<?php

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

    $response->dumpHeaders();

    $response->dumpSession();

    $response->dump();
});

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本のテスト例
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');

        $response->dumpHeaders();

        $response->dumpSession();

        $response->dump();
    }
}

あるいは、dd、ddHeaders、ddSessionメソッドを使って、レスポンスに関する情報をダンプしてから、実行を停止することもできます。Alternatively, you may use the dd, ddHeaders, and ddSession methods to dump information about the response and then stop execution:

Pest

<?php

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

    $response->ddHeaders();

    $response->ddSession();

    $response->dd();
});

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本のテスト例
     */
    public function test_basic_test(): void
    {
        $response = $this->get('/');

        $response->ddHeaders();

        $response->ddSession();

        $response->dd();
    }
}

例外処理Exception Handling

ときには、アプリケーションが特定の例外を投げているかをテストしたい場合も起きます。これを行うために、Exceptionsファサードで例外ハンドラを「Fake」できます。例外ハンドラをFakeしたら、assertReportedメソッドとassertNotReportedメソッドを使用して、 リクエスト処理中に投げられる例外に対するアサートを行います。Sometimes you may need to test that your application is throwing a specific exception. To accomplish this, you may "fake" the exception handler via the Exceptions facade. Once the exception handler has been faked, you may utilize the assertReported and assertNotReported methods to make assertions against exceptions that were thrown during the request:

Pest

<?php

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

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

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

    // ある例外が投げられることをアサート
    Exceptions::assertReported(InvalidOrderException::class);

    // 例外に対してアサート
    Exceptions::assertReported(function (InvalidOrderException $e) {
        return $e->getMessage() === 'The order was invalid.';
    });
});

PHPUnit

<?php

namespace Tests\Feature;

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

class ExampleTest extends TestCase
{
    /**
     * 基本的なテスト例。
     */
    public function test_exception_is_thrown(): void
    {
        Exceptions::fake();

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

        // ある例外が投げられることをアサート
        Exceptions::assertReported(InvalidOrderException::class);

        // 例外に対してアサート
        Exceptions::assertReported(function (InvalidOrderException $e) {
            return $e->getMessage() === 'The order was invalid.';
        });
    }
}

assertNotReportedメソッドとassertNothingReportedメソッドを使うと、リクエスト処理中に指定例外が投げられなかった、もしくは例外が全く投げられなかったことを宣言できます。The assertNotReported and assertNothingReported methods may be used to assert that a given exception was not thrown during the request or that no exceptions were thrown:

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

リクエストを行う前にwithoutExceptionHandlingメソッドを呼び出せば、指定リクエストの例外処理を完全に無効にできます。You may totally disable exception handling for a given request by invoking the withoutExceptionHandling method before making your request:

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

加えて、PHP 言語やアプリケーションが使用しているライブラリで廃止された機能をアプリケーションが使用していないことを確認したい場合は、リクエストを行う前にwithoutDeprecationHandlingメソッドを呼び出してください。この廃止例外の処理を無効にすると、deprecationの警告が例外に変換され、テストが失敗するようになります。In addition, if you would like to ensure that your application is not utilizing features that have been deprecated by the PHP language or the libraries your application is using, you may invoke the withoutDeprecationHandling method before making your request. When deprecation handling is disabled, deprecation warnings will be converted to exceptions, thus causing your test to fail:

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

assertThrowsメソッドを使用すると、指定クロージャ内のコードが、特定の型の例外を投げることを宣言できます。The assertThrows method may be used to assert that code within a given closure throws an exception of the specified type:

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

投げられた例外を検査し、アサートしたい場合は、assertThrowsメソッドの第２引数へクロージャを指定します。If you would like to inspect and make assertions against the exception that is thrown, you may provide a closure as the second argument to the assertThrows method:

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

JSON APIのテストTesting JSON APIs

Laravelは、JSON APIとそのレスポンスをテストするためのヘルパもいくつか提供しています。たとえば、json、getJson、postJson、putJson、patchJson、deleteJson、optionsJsonメソッドを使用して、さまざまなHTTP動詞でJSONリクエストを発行できます。これらのメソッドにデータとヘッダを簡単に渡すこともできます。まず、/api/userに対してPOSTリクエストを作成し、期待されるJSONデータが返されたことを宣言するテストを作成しましょう。Laravel also provides several helpers for testing JSON APIs and their responses. For example, the json, getJson, postJson, putJson, patchJson, deleteJson, and optionsJson methods may be used to issue JSON requests with various HTTP verbs. You may also easily pass data and headers to these methods. To get started, let's write a test to make a POST request to /api/user and assert that the expected JSON data was returned:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本的な機能テストの例
     */
    public function test_making_an_api_request(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);

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

さらに、JSONレスポンスデータは、レスポンス上の配列変数としてアクセスできるため、JSONレスポンス内で返された個々の値を調べるのに便利です。In addition, JSON response data may be accessed as array variables on the response, making it convenient for you to inspect the individual values returned within a JSON response:

Pest

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

PHPUnit

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

lightbulb Note: assertJsonメソッドはレスポンスを配列に変換し、指定配列がアプリケーションが返すJSONレスポンス内に存在することを確認します。したがって、JSONレスポンスに他のプロパティがある場合でも、指定するフラグメントが存在する限り、このテストは合格します。[!NOTE]
The assertJson method converts the response to an array to verify that the given array exists within the JSON response returned by the application. So, if there are other properties in the JSON response, this test will still pass as long as the given fragment is present.

厳密なJSON一致のアサートAsserting Exact JSON Matches

前述のように、assertJsonメソッドを使用して、JSONのフラグメントがJSONレスポンス内に存在することをアサートできます。指定した配列とアプリケーションが返してきたJSONが完全に一致することを確認したい場合は、assertExactJsonメソッドを使用する必要があります。As previously mentioned, the assertJson method may be used to assert that a fragment of JSON exists within the JSON response. If you would like to verify that a given array exactly matches the JSON returned by your application, you should use the assertExactJson method:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本的な機能テストの例
     */
    public function test_asserting_an_exact_json_match(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

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

JSONパスでのアサートAsserting on JSON Paths

JSONレスポンスの指定パスに指定データが含まれていることを確認する場合は、assertJsonPathメソッドを使用する必要があります。If you would like to verify that the JSON response contains the given data at a specified path, you should use the assertJsonPath method:

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 基本的な機能テストの例
     */
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

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

assertJsonPathメソッドはクロージャも引数に取れます。クロージャはアサートをパスするか動的に判断するため使用されます。The assertJsonPath method also accepts a closure, which may be used to dynamically determine if the assertion should pass:

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

FluentなJSONテストFluent JSON Testing

また、LaravelはアプリケーションのJSONレスポンスをスムーズにテストする美しい方法を提供しています。まず始めに、assertJsonメソッドにクロージャを渡します。このクロージャは、アプリケーションが返すJSONに対してアサートを行うために使用できる、Illuminate\Testing\Fluent\AssertableJsonのインスタンスで呼び出されます。whereメソッドはJSONの特定の属性に対してアサートを行うために使用でき、missingメソッドはJSONに特定の属性がないことをアサートするために使用できます。Laravel also offers a beautiful way to fluently test your application's JSON responses. To get started, pass a closure to the assertJson method. This closure will be invoked with an instance of Illuminate\Testing\Fluent\AssertableJson which can be used to make assertions against the JSON that was returned by your application. The where method may be used to make assertions against a particular attribute of the JSON, while the missing method may be used to assert that a particular attribute is missing from the JSON:

Pest

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

PHPUnit

use Illuminate\Testing\Fluent\AssertableJson;

/**
 * 基本的な機能テスト例
 */
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メソッドを理解するUnderstanding the etc Method

上記の例では、アサートのチェーンの最後でetcメソッドを呼び出したことに気づかれた方もいらっしゃるでしょう。このメソッドはLaravelへJSONオブジェクト中に他の属性が存在する可能性があることを伝えます。etcメソッドが使用されていない場合は、JSONオブジェクトに他の属性が存在していることをアサートしていないため、テストは失敗します。In the example above, you may have noticed we invoked the etc method at the end of our assertion chain. This method informs Laravel that there may be other attributes present on the JSON object. If the etc method is not used, the test will fail if other attributes that you did not make assertions against exist on the JSON object.

この動作の意図は、属性に対して明示的にアサートを行うか、etc メソッドで追加の属性を明示的に許可することで、JSONレスポンスで意図せず機密情報を公開してしまうことを防ぐことにあります。The intention behind this behavior is to protect you from unintentionally exposing sensitive information in your JSON responses by forcing you to either explicitly make an assertion against the attribute or explicitly allow additional attributes via the etc method.

しかし、etcメソッドをアサートのチェーンに含めないからといっても、JSONオブジェクトのネストに含まれる配列へ、追加の属性が追加されないわけではないことを認識しておく必要はあります。etcメソッドは、etcメソッドを呼び出したネストレベルで、追加の属性が存在しないことを保証するだけです。However, you should be aware that not including the etc method in your assertion chain does not ensure that additional attributes are not being added to arrays that are nested within your JSON object. The etc method only ensures that no additional attributes exist at the nesting level in which the etc method is invoked.

属性の有無をアサートするAsserting Attribute Presence / Absence

属性が存在しているかどうかをアサートするには、hasとmissingメソッドを使います。To assert that an attribute is present or absent, you may use the has and missing methods:

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

さらに、hasAllとmissingAllメソッドは、複数の属性の有無を同時にアサートできます。In addition, the hasAll and missingAll methods allow asserting the presence or absence of multiple attributes simultaneously:

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

hasAnyメソッドを使用して、指定する属性リスト中に少なくとも１つ存在しているか判断できます。You may use the hasAny method to determine if at least one of a given list of attributes is present:

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

JSONコレクションに対するアサートAsserting Against JSON Collections

多くの場合、ルートは複数のユーザーなど、複数の項目を含むJSONレスポンスを返します。Often, your route will return a JSON response that contains multiple items, such as multiple users:

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

このような状況では、レスポンスに含まれているユーザーに対するアサートを行うために、fluentなJSONオブジェクトのhasメソッドを使用することができます。例として、JSONレスポンスに３つのユーザーが含まれていることをアサートしましょう。次に、firstメソッドを使用して、コレクション内の最初のユーザーに関するいくつかのアサートを行います。firstメソッドは、JSONコレクション内の最初のオブジェクトに関するアサートを行うために使用できる別のアサートJSON文字列を受信するクロージャを引数に取ります。In these situations, we may use the fluent JSON object's has method to make assertions against the users included in the response. For example, let's assert that the JSON response contains three users. Next, we'll make some assertions about the first user in the collection using the first method. The first method accepts a closure which receives another assertable JSON string that we can use to make assertions about the first object in the JSON collection:

$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コレクションをスコープするアサーションScoping JSON Collection Assertions

時々、アプリケーションのルートは名前付きキーが割り当てられているJSONコレクションを返します。Sometimes, your application's routes will return JSON collections that are assigned named keys:

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

これらのルートをテストするときは、コレクション内の項目数に対してhasメソッドを使えます。さらに、hasメソッドを使用してアサーションチェーンをスコープできます。When testing these routes, you may use the has method to assert against the number of items in the collection. In addition, you may use the has method to scope a chain of assertions:

$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コレクションにhasコレクションにアサートする２つの別々の呼び出しをするのではなく、クロージャを３番目の引数に渡す呼び出し一つにまとめられます。これで、クロージャが自動的に呼び出され、コレクション内の最初の項目にスコープされます。However, instead of making two separate calls to the has method to assert against the users collection, you may make a single call which provides a closure as its third parameter. When doing so, the closure will automatically be invoked and scoped to the first item in the collection:

$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タイプのアサートAsserting JSON Types

JSONレスポンス内のプロパティが特定の型のものであることをアサートできます。Illuminate\Testing\Fluent\AssertableJsonクラスは、これを行うwhereTypeとwhereAllTypeメソッドを提供しています。You may only want to assert that the properties in the JSON response are of a certain type. The Illuminate\Testing\Fluent\AssertableJson class provides the whereType and whereAllType methods for doing just that:

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

複数のタイプを指定するには | 文字を使用するか、タイプの配列を whereType メソッドの 2 番目のパラメータとして渡します。レスポンスの値がリストアップされたタイプのいずれかであれば、アサーションは成功します。You may specify multiple types using the | character, or passing an array of types as the second parameter to the whereType method. The assertion will be successful if the response value is any of the listed types:

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

whereTypeとwhereAllTypeメソッドは、string、integer、double、boolean、array、nullタイプを認識します。The whereType and whereAllType methods recognize the following types: string, integer, double, boolean, array, and null.

ファイルアップロードのテストTesting File Uploads

Illuminate\Http\UploadedFileクラスは、テスト用のダミーファイルまたは画像を生成するために使用できるfakeメソッドを提供しています。これをStorageファサードのfakeメソッドと組み合わせると、ファイルアップロードのテストが大幅に簡素化されます。たとえば、次の２つの機能を組み合わせて、アバターのアップロードフォームを簡単にテストできます。The Illuminate\Http\UploadedFile class provides a fake method which may be used to generate dummy files or images for testing. This, combined with the Storage facade's fake method, greatly simplifies the testing of file uploads. For example, you may combine these two features to easily test an avatar upload form:

Pest

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

PHPUnit

<?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メソッドを使用できます。If you would like to assert that a given file does not exist, you may use the assertMissing method provided by the Storage facade:

Storage::fake('avatars');

// ...

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

fakeファイルのカスタマイズFake File Customization

UploadedFileクラスが提供するfakeメソッドを使用してファイルを作成する場合、アプリケーションのバリデーションルールをより適切にテストするために、画像の幅、高さ、およびサイズ(キロバイト単位)を指定できます。When creating files using the fake method provided by the UploadedFile class, you may specify the width, height, and size of the image (in kilobytes) in order to better test your application's validation rules:

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

画像に加えて、createメソッドを使用して他のタイプのファイルも作成できます。In addition to creating images, you may create files of any other type using the create method:

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

必要に応じて、メソッドに$mimeType引数を渡し、ファイルが返すMIMEタイプを明示的に定義できます。If needed, you may pass a $mimeType argument to the method to explicitly define the MIME type that should be returned by the file:

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

ビューのテストTesting Views

Laravelを使用すると、アプリケーションに対してシミュレートするHTTPリクエストを作成せずにビューをレンダすることもできます。それには、テスト内でviewメソッドを呼び出してください。viewメソッドは、ビュー名とオプションのデータ配列を引数に取ります。このメソッドはIlluminate\Testing\TestViewのインスタンスを返します。これは、ビューのコンテンツに関するアサートを簡単に作成するためのメソッドをいくつか提供しています。Laravel also allows you to render a view without making a simulated HTTP request to the application. To accomplish this, you may call the view method within your test. The view method accepts the view name and an optional array of data. The method returns an instance of Illuminate\Testing\TestView, which offers several methods to conveniently make assertions about the view's contents:

Pest

<?php

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

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

PHPUnit

<?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、assertDontSeeTextThe TestView class provides the following assertion methods: assertSee, assertSeeInOrder, assertSeeText, assertSeeTextInOrder, assertDontSee, and assertDontSeeText.

必要に応じて、TestViewインスタンスを文字列にキャストすることで、レンダリングされた素のビューコンテンツを取得できます。If needed, you may get the raw, rendered view contents by casting the TestView instance to a string:

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

エラーの共有Sharing Errors

一部のビューは、Laravelが提供するグローバルエラーバッグで共有されるエラーに依存する場合があります。エラーバッグをエラーメッセージでハイドレイトするには、withViewErrorsメソッドを使用できます。Some views may depend on errors shared in the global error bag provided by Laravel[/docs/{{version}}/validation#quick-displaying-the-validation-errors]. To hydrate the error bag with error messages, you may use the withViewErrors method:

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

$view->assertSee('Please provide a valid name.');

BladeとコンポーネントのレンダRendering Blade and Components

必要に応じて、bladeメソッドを使用して、素のBlade文字列を評価およびレンダできます。viewメソッドと同様に、bladeメソッドはIlluminate\Testing\TestViewのインスタンスを返します。If necessary, you may use the blade method to evaluate and render a raw Blade[/docs/{{version}}/blade] string. Like the view method, the blade method returns an instance of Illuminate\Testing\TestView:

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

$view->assertSee('Taylor');

componentメソッドを使用して、ブレードコンポーネントを評価およびレンダできます。componentメソッドはIlluminate\Testing\TestComponentのインスタンスを返します。You may use the component method to evaluate and render a Blade component[/docs/{{version}}/blade#components]. The component method returns an instance of Illuminate\Testing\TestComponent:

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

$view->assertSee('Taylor');

利用可能なアサートAvailable Assertions

レスポンスのアサートResponse Assertions

LaravelのIlluminate\Testing\TestResponseクラスは、アプリケーションをテストするときに利用できるさまざまなカスタムアサートメソッドを提供します。これらのアサートは、json、get、post、put、deleteテストメソッドが返すレスポンスからアクセスできます。Laravel's Illuminate\Testing\TestResponse class provides a variety of custom assertion methods that you may utilize when testing your application. These assertions may be accessed on the response that is returned by the json, get, post, put, and delete test methods:

assertBadRequestassertBadRequest

レスポンスのHTTPステータスコードが、Bad Request（400）であることを宣言します。Assert that the response has a bad request (400) HTTP status code:

$response->assertBadRequest();

assertAcceptedassertAccepted

レスポンスのHTTPステータスコードが、accepted（202）であることを宣言します。Assert that the response has an accepted (202) HTTP status code:

$response->assertAccepted();

assertConflictassertConflict

レスポンスのHTTPステータスコードが、conflict（409）であることを宣言します。Assert that the response has a conflict (409) HTTP status code:

$response->assertConflict();

assertCookieassertCookie

レスポンスに指定するクッキーが含まれていることを宣言します。Assert that the response contains the given cookie:

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

assertCookieExpiredassertCookieExpired

レスポンスに指定するクッキーが含まれており、有効期限が切れていることを宣言します。Assert that the response contains the given cookie and it is expired:

$response->assertCookieExpired($cookieName);

assertCookieNotExpiredassertCookieNotExpired

レスポンスに指定するクッキーが含まれており、有効期限が切れていないことを宣言します。Assert that the response contains the given cookie and it is not expired:

$response->assertCookieNotExpired($cookieName);

assertCookieMissingassertCookieMissing

レスポンスに指定するクッキーが含まれていないことを宣言します。Assert that the response does not contain the given cookie:

$response->assertCookieMissing($cookieName);

assertCreatedassertCreated

レスポンスに201 HTTPステータスコードがあることを宣言します。Assert that the response has a 201 HTTP status code:

$response->assertCreated();

assertDontSeeassertDontSee

指定する文字列が、アプリケーションが返すレスポンスに含まれていないことを宣言します。このアサートは、２番目の引数にfalseを渡さない限り、指定する文字列を自動的にエスケープします。Assert that the given string is not contained within the response returned by the application. This assertion will automatically escape the given string unless you pass a second argument of false:

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

assertDontSeeTextassertDontSeeText

指定する文字列がレスポンステキストに含まれていないことを宣言します。このアサートは、２番目の引数にfalseを渡さない限り、指定する文字列を自動的にエスケープします。このメソッドは、アサートを作成する前に、レスポンスコンテンツをstrip_tags PHP関数へ渡します。Assert that the given string is not contained within the response text. This assertion will automatically escape the given string unless you pass a second argument of false. This method will pass the response content to the strip_tags PHP function before making the assertion:

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

assertDownloadassertDownload

レスポンスが「ダウンロード」であることを宣言します。通常、Response::downloadレスポンス、BinaryFileResponse、またはStorage::downloadレスポンスを返すルートが起動されたことを意味します。Assert that the response is a "download". Typically, this means the invoked route that returned the response returned a Response::download response, BinaryFileResponse, or Storage::download response:

$response->assertDownload();

お望みであれば、ダウンロード可能なファイルに指定のファイル名が付与されていることを宣言することもできます。If you wish, you may assert that the downloadable file was assigned a given file name:

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

assertExactJsonassertExactJson

レスポンスが、完全一致する指定JSONデータを含んでいることを宣言します。Assert that the response contains an exact match of the given JSON data:

$response->assertExactJson(array $data);

assertExactJsonStructureassertExactJsonStructure

レスポンスが、指定JSON構造と完全に一致するものを含んでいることを宣言します。Assert that the response contains an exact match of the given JSON structure:

$response->assertExactJsonStructure(array $data);

このメソッドは、assertJsonStructureをより厳密にしたものです。assertJsonStructureとは対照的に、このメソッドは、レスポンスが明示的に期待されていないJSON構造のキーを含む場合、失敗します。This method is a more strict variant of assertJsonStructure[#assert-json-structure]. In contrast with assertJsonStructure, this method will fail if the response contains any keys that aren't explicitly included in the expected JSON structure.

assertForbiddenassertForbidden

レスポンスにForbidden（403）HTTPステータスコードがあることを宣言します。Assert that the response has a forbidden (403) HTTP status code:

$response->assertForbidden();

assertFoundassertFound

レスポンスのHTTPステータスコードが、found（302）であることを宣言します。Assert that the response has a found (302) HTTP status code:

$response->assertFound();

assertGoneassertGone

レスポンスのHTTPステータスコードが、gone（410）であることを宣言します。Assert that the response has a gone (410) HTTP status code:

$response->assertGone();

assertHeaderassertHeader

指定するヘッダと値がレスポンスに存在することを宣言します。Assert that the given header and value is present on the response:

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

assertHeaderMissingassertHeaderMissing

指定するヘッダがレスポンスに存在しないことを宣言します。Assert that the given header is not present on the response:

$response->assertHeaderMissing($headerName);

assertInternalServerErrorassertInternalServerError

レスポンスのHTTPステータスコードが、Internal Server Error（500）であることを宣言します。Assert that the response has an "Internal Server Error" (500) HTTP status code:

$response->assertInternalServerError();

assertJsonassertJson

レスポンスに指定するJSONデータが含まれていることを宣言します。Assert that the response contains the given JSON data:

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

assertJsonメソッドはレスポンスを配列に変換し、指定する配列がアプリケーションが返すJSONレスポンス内に存在していることを確認します。したがって、JSONレスポンスに他のプロパティがある場合でも、指定するフラグメントが存在する限り、このテストは合格します。The assertJson method converts the response to an array to verify that the given array exists within the JSON response returned by the application. So, if there are other properties in the JSON response, this test will still pass as long as the given fragment is present.

assertJsonCountassertJsonCount

レスポンスJSONに、指定するキーに予想されるアイテム数の配列があることを宣言します。Assert that the response JSON has an array with the expected number of items at the given key:

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

assertJsonFragmentassertJsonFragment

レスポンス中のどこかに指定JSONデータが含まれていることを宣言します。Assert that the response contains the given JSON data anywhere in the response:

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

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

assertJsonIsArrayassertJsonIsArray

レスポンスのJSONが、配列であることを宣言します。Assert that the response JSON is an array:

$response->assertJsonIsArray();

assertJsonIsObjectassertJsonIsObject

レスポンスのJSONが、オブジェクトであることを宣言します。Assert that the response JSON is an object:

$response->assertJsonIsObject();

assertJsonMissingassertJsonMissing

レスポンスに指定するJSONデータが含まれていないことを宣言します。Assert that the response does not contain the given JSON data:

$response->assertJsonMissing(array $data);

assertJsonMissingExactassertJsonMissingExact

レスポンスに完全一致するJSONデータが含まれていないことを宣言します。Assert that the response does not contain the exact JSON data:

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrorsassertJsonMissingValidationErrors

指定するキーのJSONバリデーションエラーがレスポンスにないことを宣言します。Assert that the response has no JSON validation errors for the given keys:

$response->assertJsonMissingValidationErrors($keys);

lightbulb Note: より一般的なassertValidメソッドを使用して、JSONで返されたレスポンスにバリデーションエラーがなく、かつセッションストレージにエラーが一時保存されていないことを宣言できます。[!NOTE]
The more generic assertValid[#assert-valid] method may be used to assert that a response does not have validation errors that were returned as JSON and that no errors were flashed to session storage.

assertJsonPathassertJsonPath

レスポンスに、指定するパスの指定するデータが含まれていることを宣言します。Assert that the response contains the given data at the specified path:

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

たとえば、アプリケーションが以下のJSONレスポンスを返す場合：For example, if the following JSON response is returned by your application:

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

userオブジェクトのnameプロパティが次のように指定する値に一致すると宣言することができます。You may assert that the name property of the user object matches a given value like so:

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

assertJsonMissingPathassertJsonMissingPath

レスポンスに、指定するパスが含まれないことを宣言します。Assert that the response does not contain the given path:

$response->assertJsonMissingPath($path);

たとえば、アプリケーションが以下のJSONレスポンスを返す場合：For example, if the following JSON response is returned by your application:

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

userオブジェクトにemailプロパティが含まれていないことを宣言できるでしょう。You may assert that it does not contain the email property of the user object:

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

assertJsonStructureassertJsonStructure

レスポンスが指定のJSON構造を持っていることを宣言します。Assert that the response has a given JSON structure:

$response->assertJsonStructure(array $structure);

たとえば、アプリケーションが返すJSONレスポンスに次のデータが含まれている場合:For example, if the JSON response returned by your application contains the following data:

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

次のように、JSON構造がエクスペクテーションに一致すると宣言できます。You may assert that the JSON structure matches your expectations like so:

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

時々、アプリケーションが返すJSONレスポンスには、オブジェクトの配列が含まれている可能性があります。Sometimes, JSON responses returned by your application may contain arrays of objects:

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

この状況では、*文字を使って配列内のすべてのオブジェクトの構造に対して宣言できます。In this situation, you may use the * character to assert against the structure of all of the objects in the array:

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

assertJsonValidationErrorsassertJsonValidationErrors

レスポンスへ、指定するキーに対する指定するJSONバリデーションエラーがあることを宣言します。このメソッドは、バリデーションエラーがセッションに一時保存されているのではなく、バリデーションエラーをJSON構造として返すレスポンスに対して宣言する場合に使用する必要があります。Assert that the response has the given JSON validation errors for the given keys. This method should be used when asserting against responses where the validation errors are returned as a JSON structure instead of being flashed to the session:

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

lightbulb Note: より一般的なassertInvalidメソッドを使用して、JSONで返されたレスポンスにバリデーションエラーが存在した、もしくはエラーがセッションストレージに一時保存されたことを宣言できます。[!NOTE]
The more generic assertInvalid[#assert-invalid] method may be used to assert that a response has validation errors returned as JSON or that errors were flashed to session storage.

assertJsonValidationErrorForassertJsonValidationErrorFor

レスポンスが指定キーに対するJSONバリデーションエラーを持っていることを宣言します。Assert the response has any JSON validation errors for the given key:

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

assertMethodNotAllowedassertMethodNotAllowed

レスポンスのHTTPステータスコードが、method not allowed（405）であることを宣言します。Assert that the response has a method not allowed (405) HTTP status code:

$response->assertMethodNotAllowed();

assertMovedPermanentlyassertMovedPermanently

レスポンスのHTTPステータスコードが、moved permanently（301）であることを宣言します。Assert that the response has a moved permanently (301) HTTP status code:

$response->assertMovedPermanently();

assertLocationassertLocation

レスポンスのLocationヘッダに指定するURI値があることを宣言します。Assert that the response has the given URI value in the Location header:

$response->assertLocation($uri);

assertContentassertContent

指定した文字列が、レスポンスの内容と一致することを宣言します。Assert that the given string matches the response content:

$response->assertContent($value);

assertNoContentassertNoContent

レスポンスに指定するHTTPステータスコードがあり、コンテンツがないことを宣言します。Assert that the response has the given HTTP status code and no content:

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

assertStreamedContentassertStreamedContent

指定文字列がストリームしたレスポンスの内容に一致することを宣言します。Assert that the given string matches the streamed response content:

$response->assertStreamedContent($value);

assertNotFoundassertNotFound

レスポンスにNot Found（404）HTTPステータスコードがあることを宣言します。Assert that the response has a not found (404) HTTP status code:

$response->assertNotFound();

assertOkassertOk

レスポンスに200 HTTPステータスコードがあることを宣言します。Assert that the response has a 200 HTTP status code:

$response->assertOk();

assertPaymentRequiredassertPaymentRequired

レスポンスのHTTPステータスコードが、payment required（402）であることを宣言します。Assert that the response has a payment required (402) HTTP status code:

$response->assertPaymentRequired();

assertPlainCookieassertPlainCookie

レスポンスに指定する暗号化されていないクッキーが含まれていることを宣言します。Assert that the response contains the given unencrypted cookie:

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

assertRedirectassertRedirect

レスポンスが指定するURIへのリダイレクトであることを宣言します。Assert that the response is a redirect to the given URI:

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

assertRedirectContainsassertRedirectContains

レスポンスが指定文字列を含むURIへリダイレクトされることを宣言します。Assert whether the response is redirecting to a URI that contains the given string:

$response->assertRedirectContains($string);

assertRedirectToRouteassertRedirectToRoute

レスポンスが指定名前付きルートへリダイレクトすることを宣言します。Assert that the response is a redirect to the given named route[/docs/{{version}}/routing#named-routes]:

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

assertRedirectToSignedRouteassertRedirectToSignedRoute

レスポンスが指定署名付きルートへリダイレクトすることを宣言します。Assert that the response is a redirect to the given signed route[/docs/{{version}}/urls#signed-urls]:

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

assertRequestTimeoutassertRequestTimeout

レスポンスのHTTPステータスコードが、request timeout（408）であることを宣言します。Assert that the response has a request timeout (408) HTTP status code:

$response->assertRequestTimeout();

assertSeeassertSee

指定する文字列がレスポンスに含まれていることを宣言します。このアサートは、２番目の引数にfalseを渡さない限り、指定する文字列を自動的にエスケープします。Assert that the given string is contained within the response. This assertion will automatically escape the given string unless you pass a second argument of false:

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

assertSeeInOrderassertSeeInOrder

指定する文字列がレスポンス内に順番に含まれていることを宣言します。このアサートは、2番目の引数へfalseを渡さない限り、指定する文字列を自動的にエスケープします。Assert that the given strings are contained in order within the response. This assertion will automatically escape the given strings unless you pass a second argument of false:

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

assertSeeTextassertSeeText

指定する文字列がレスポンステキストに含まれていることを宣言します。このアサートは、2番目の引数にfalseを渡さない限り、指定する文字列を自動的にエスケープします。アサートが作成される前に、レスポンスの内容がstrip_tagsPHP関数に渡されます。Assert that the given string is contained within the response text. This assertion will automatically escape the given string unless you pass a second argument of false. The response content will be passed to the strip_tags PHP function before the assertion is made:

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

assertSeeTextInOrderassertSeeTextInOrder

指定する文字列がレスポンステキスト内に順番に含まれていることを宣言します。このアサートは、２番目の引数にfalseを渡さない限り、指定する文字列を自動的にエスケープします。アサートが作成される前に、レスポンスの内容がstrip_tagsPHP関数に渡されます。Assert that the given strings are contained in order within the response text. This assertion will automatically escape the given strings unless you pass a second argument of false. The response content will be passed to the strip_tags PHP function before the assertion is made:

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

assertServerErrorassertServerError

レスポンスのHTTPステータスコードが、サーバエラー（500以上、600より小さい）であることを宣言します。Assert that the response has a server error (>= 500 , < 600) HTTP status code:

$response->assertServerError();

assertServiceUnavailableassertServiceUnavailable

レスポンスのHTTPステータスコードが、Service Unavailable（503）であることを宣言します。Assert that the response has a "Service Unavailable" (503) HTTP status code:

$response->assertServiceUnavailable();

assertSessionHasassertSessionHas

セッションに指定するデータが含まれていることを宣言します。Assert that the session contains the given piece of data:

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

必要であれば、クロージャをassertSessionHasメソッドの第２引数へ指定できます。クロージャがtrueを返せば、アサートは成功します。If needed, a closure can be provided as the second argument to the assertSessionHas method. The assertion will pass if the closure returns true:

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

assertSessionHasInputassertSessionHasInput

セッションの一時保存されている入力配列に指定する値があることを宣言します。Assert that the session has a given value in the flashed input array[/docs/{{version}}/responses#redirecting-with-flashed-session-data]:

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

必要であれば、クロージャをassertSessionHasInputメソッドの第２引数へ指定できます。クロージャがtrueを返せば、アサートは成功します。If needed, a closure can be provided as the second argument to the assertSessionHasInput method. The assertion will pass if the closure returns true:

use Illuminate\Support\Facades\Crypt;

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

assertSessionHasAllassertSessionHasAll

セッションにキー／値ペアの指定配列が含まれていることを宣言します。Assert that the session contains a given array of key / value pairs:

$response->assertSessionHasAll(array $data);

たとえば、アプリケーションのセッションにnameキーとstatusキーが含まれている場合、両方が存在し、以下のような指定値を持っていると宣言できます。For example, if your application's session contains name and status keys, you may assert that both exist and have the specified values like so:

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

assertSessionHasErrorsassertSessionHasErrors

指定する$keysのエラーがセッションに含まれていることを宣言します。$keysが連想配列の場合、セッションに各フィールド(キー)の特定のエラーメッセージ(値)が含まれていることを宣言します。このメソッドは、バリデーションエラーをJSON構造として返すのではなく、セッションに一時保存するルートをテストするときに使用する必要があります。Assert that the session contains an error for the given $keys. If $keys is an associative array, assert that the session contains a specific error message (value) for each field (key). This method should be used when testing routes that flash validation errors to the session instead of returning them as a JSON structure:

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

たとえば、nameフィールドとemailフィールドにセッションへ一時保存された検証エラーメッセージがあることを宣言するには、以下のようにassertSessionHasErrorsメソッドを呼び出すことができます。For example, to assert that the name and email fields have validation error messages that were flashed to the session, you may invoke the assertSessionHasErrors method like so:

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

または、特定のフィールドに特定のバリデーションエラーメッセージがあると宣言することもできます。Or, you may assert that a given field has a particular validation error message:

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

lightbulb Note: より一般的なassertInvalidメソッドを使用して、JSONで返されたレスポンスにバリデーションエラーが存在した、もしくはエラーがセッションストレージに一時保存されたことを宣言できます。[!NOTE]
The more generic assertInvalid[#assert-invalid] method may be used to assert that a response has validation errors returned as JSON or that errors were flashed to session storage.

assertSessionHasErrorsInassertSessionHasErrorsIn

指定エラーバッグ内に指定する$keysのエラーがセッションに含まれていることを宣言します。$keysが連想配列の場合、セッションにはエラーバッグ内の各フィールド(キー)に特定のエラーメッセージ(値)が含まれていることを宣言します。Assert that the session contains an error for the given $keys within a specific error bag[/docs/{{version}}/validation#named-error-bags]. If $keys is an associative array, assert that the session contains a specific error message (value) for each field (key), within the error bag:

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

assertSessionHasNoErrorsassertSessionHasNoErrors

セッションにバリデーションエラーがないことを宣言します。Assert that the session has no validation errors:

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrorsassertSessionDoesntHaveErrors

指定するキーのバリデーションエラーがセッションにないことを宣言します。Assert that the session has no validation errors for the given keys:

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

lightbulb Note: より一般的なassertValidメソッドを使用して、JSONで返されたレスポンスにバリデーションエラーがなく、かつセッションストレージにエラーが一時保存されていないことを宣言できます。[!NOTE]
The more generic assertValid[#assert-valid] method may be used to assert that a response does not have validation errors that were returned as JSON and that no errors were flashed to session storage.

assertSessionMissingassertSessionMissing

セッションに指定するキーが含まれていないことを宣言します。Assert that the session does not contain the given key:

$response->assertSessionMissing($key);

assertStatusassertStatus

レスポンスに指定HTTPステータスコードがあることを宣言します。Assert that the response has a given HTTP status code:

$response->assertStatus($code);

assertSuccessfulassertSuccessful

レスポンスに成功した(>=200および<300)HTTPステータスコードがあることを宣言します。Assert that the response has a successful (>= 200 and < 300) HTTP status code:

$response->assertSuccessful();

assertTooManyRequestsassertTooManyRequests

レスポンスのHTTPステータスコードが、too many requests（429）であることを宣言します。Assert that the response has a too many requests (429) HTTP status code:

$response->assertTooManyRequests();

assertUnauthorizedassertUnauthorized

レスポンスに不正な(401)HTTPステータスコードがあることを宣言します。Assert that the response has an unauthorized (401) HTTP status code:

$response->assertUnauthorized();

assertUnprocessableassertUnprocessable

レスポンスに未処理のエンティティ(422)HTTPステータスコードがあることを宣言します。Assert that the response has an unprocessable entity (422) HTTP status code:

$response->assertUnprocessable();

assertUnsupportedMediaTypeassertUnsupportedMediaType

レスポンスのHTTPステータスコードが、unsupported media type（415）であることを宣言します。Assert that the response has an unsupported media type (415) HTTP status code:

$response->assertUnsupportedMediaType();

assertValidassertValid

レスポンスに指定キーのバリデーションエラーがないことを宣言します。このメソッドは、バリデーションエラーをJSON構造として返す、もしくはバリデーションエラーをセッションへ一時保存しているレスポンスに対する宣言に使用します。Assert that the response has no validation errors for the given keys. This method may be used for asserting against responses where the validation errors are returned as a JSON structure or where the validation errors have been flashed to the session:

// バリデーションエラーが発生していないことを宣言
$response->assertValid();

// 指定キーのバリデーションエラーがないことを宣言
$response->assertValid(['name', 'email']);

assertInvalidassertInvalid

レスポンスに指定キーのバリデーションエラーがあることを宣言します。このメソッドは、バリデーションエラーをJSON構造として返す、もしくはバリデーションエラーをセッションへ一時保存しているレスポンスに対する宣言に使用します。Assert that the response has validation errors for the given keys. This method may be used for asserting against responses where the validation errors are returned as a JSON structure or where the validation errors have been flashed to the session:

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

特定のキーに特定のバリデーションエラーメッセージがあることを宣言することもできます。その場合、メッセージ全体またはメッセージのごく一部だけを指定できます。You may also assert that a given key has a particular validation error message. When doing so, you may provide the entire message or only a small portion of the message:

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

assertViewHasassertViewHas

指定するデータの部分がレスポンスビューに含まれていることを宣言します。Assert that the response view contains a given piece of data:

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

assertViewHasメソッドの２番目の引数にクロージャを渡すと、ビューデータの特定部分に対して検査し、アサートできます。Passing a closure as the second argument to the assertViewHas method will allow you to inspect and make assertions against a particular piece of view data:

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

さらに、ビューデータはレスポンスの配列変数としてアクセスできるため、次のように簡単に検査できます。In addition, view data may be accessed as array variables on the response, allowing you to conveniently inspect it:

Pest

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

PHPUnit

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

assertViewHasAllassertViewHasAll

レスポンスビューに指定するデータのリストがあることを宣言します。Assert that the response view has a given list of data:

$response->assertViewHasAll(array $data);

このメソッドは、ビューに指定するキーに一致するデータが含まれていることを宣言するために使用できます。This method may be used to assert that the view simply contains data matching the given keys:

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

または、ビューデータが存在し、特定の値を持っていると宣言することもできます。Or, you may assert that the view data is present and has specific values:

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

assertViewIsassertViewIs

指定するビューがルートによって返されたことを宣言します。Assert that the given view was returned by the route:

$response->assertViewIs($value);

assertViewMissingassertViewMissing

指定するデータキーが、アプリケーションのレスポンスで返されたビューで使用可能になっていないことを宣言します。Assert that the given data key was not made available to the view returned in the application's response:

$response->assertViewMissing($key);

認証のアサートAuthentication Assertions

Laravelは、アプリケーションの機能テストで利用できるさまざまな認証関連のアサートも提供します。これらのメソッドは、getやpostなどのメソッドによって返されるIlluminate\Testing\TestResponseインスタンスではなく、テストクラス自体で呼び出されることに注意してください。Laravel also provides a variety of authentication related assertions that you may utilize within your application's feature tests. Note that these methods are invoked on the test class itself and not the Illuminate\Testing\TestResponse instance returned by methods such as get and post.

assertAuthenticatedassertAuthenticated

ユーザーが認証済みであることを宣言します。Assert that a user is authenticated:

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

assertGuestassertGuest

ユーザーが認証されていないことを宣言します。Assert that a user is not authenticated:

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

assertAuthenticatedAsassertAuthenticatedAs

特定のユーザーが認証済みであることを宣言します。Assert that a specific user is authenticated:

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

バリデーションのアサートValidation Assertions

Laravelは、リクエストが提供するデータが有効か無効かを確認するために使用する、２つの主要なバリデーションに関連したアサートを提供しています。Laravel provides two primary validation related assertions that you may use to ensure the data provided in your request was either valid or invalid.

assertValidassertValid

レスポンスに指定キーのバリデーションエラーがないことを宣言します。このメソッドは、バリデーションエラーをJSON構造として返す、もしくはバリデーションエラーをセッションへ一時保存しているレスポンスに対する宣言に使用します。Assert that the response has no validation errors for the given keys. This method may be used for asserting against responses where the validation errors are returned as a JSON structure or where the validation errors have been flashed to the session:

// バリデーションエラーが発生していないことを宣言
$response->assertValid();

// 指定キーのバリデーションエラーがないことを宣言
$response->assertValid(['name', 'email']);

assertInvalidassertInvalid

レスポンスに指定キーのバリデーションエラーがあることを宣言します。このメソッドは、バリデーションエラーをJSON構造として返す、もしくはバリデーションエラーをセッションへ一時保存しているレスポンスに対する宣言に使用します。Assert that the response has validation errors for the given keys. This method may be used for asserting against responses where the validation errors are returned as a JSON structure or where the validation errors have been flashed to the session:

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

特定のキーに特定のバリデーションエラーメッセージがあることを宣言することもできます。その場合、メッセージ全体またはメッセージのごく一部だけを指定できます。You may also assert that a given key has a particular validation error message. When doing so, you may provide the entire message or only a small portion of the message:

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