HTTP 테스트

업데이트됨

번역일: 2026년 9월 17일

이 페이지는 원문이 업데이트되어 번역이 갱신되었습니다.

원문 수정: 2026년 9월 17일
번역 갱신: 2026년 9월 17일

HTTP 테스트

소개
요청 보내기
JSON API 테스트하기
- 플루언트 JSON 테스트
파일 업로드 테스트하기
뷰 테스트하기
- Blade와 컴포넌트 렌더링
라우트 캐싱
사용 가능한 단언(Assertion)

HTTP 테스트

소개

Laravel은 애플리케이션에 HTTP 요청을 보내고 그 응답을 검사할 수 있는 매우 유려한(fluent) API를 제공합니다. 예를 들어 아래에 정의된 기능 테스트를 살펴보겠습니다.

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
{
    /**
     * 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 구조 등을 검사할 수 있는 다양한 단언 메서드를 제공합니다.

NOTE

테스트를 처음 작성해 보신다면, 하나의 요청에 여러 단언을 이어 붙이는 이 방식이 낯설게 느껴질 수 있습니다. 하지만 익숙해지면 $response->assertStatus(200)->assertSee('환영합니다')처럼 체이닝 형태로 여러 검증을 한 번에 표현할 수 있어 테스트 코드가 훨씬 간결해집니다.

HTTP 테스트

요청 보내기

애플리케이션에 요청을 보내려면 테스트 코드 안에서 get, post, put, patch, delete 메서드를 호출하면 됩니다. 이 메서드들은 실제로 애플리케이션에 "진짜" HTTP 요청을 전송하지는 않습니다. 대신 네트워크 요청 전체가 내부적으로 시뮬레이션됩니다.

이 메서드들은 Illuminate\Http\Response 인스턴스 대신 Illuminate\Testing\TestResponse 인스턴스를 반환하는데, 이 클래스는 애플리케이션의 응답을 검사할 수 있는 다양한 유용한 검증 메서드를 제공합니다.

Pest

<?php

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

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

PHPUnit

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

일반적으로 하나의 테스트에서는 애플리케이션에 요청을 한 번만 보내는 것이 좋습니다. 하나의 테스트 메서드 안에서 여러 번 요청을 실행하면 예상치 못한 동작이 발생할 수 있습니다.

NOTE

편의를 위해 테스트를 실행할 때는 CSRF 미들웨어가 자동으로 비활성화됩니다.

요청 헤더 커스터마이징

withHeaders 메서드를 사용하면 애플리케이션에 요청을 보내기 전에 요청 헤더를 원하는 대로 설정할 수 있습니다. 이 메서드를 통해 원하는 커스텀 헤더를 요청에 자유롭게 추가할 수 있습니다.

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
{
    /**
     * 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);
    }
}

쿠키

요청을 보내기 전에 쿠키 값을 설정하려면 withCookie 또는 withCookies 메서드를 사용할 수 있습니다. withCookie 메서드는 쿠키 이름과 값을 인수로 받고, withCookies 메서드는 이름/값 쌍으로 구성된 배열을 인수로 받습니다.

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

        //
    }
}

세션 / 인증

라라벨은 HTTP 테스트 도중 세션을 다루기 위한 여러 헬퍼를 제공합니다. 먼저 withSession 메서드를 사용하면 주어진 배열로 세션 데이터를 설정할 수 있습니다. 이는 애플리케이션에 요청을 보내기 전에 세션에 미리 데이터를 채워 넣고 싶을 때 유용합니다.

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

        //
    }
}

라라벨의 세션은 보통 현재 인증된 사용자의 상태를 유지하는 데 사용됩니다. 따라서 actingAs 헬퍼 메서드를 사용하면 특정 사용자를 현재 인증된 사용자로 간편하게 설정할 수 있습니다. 예를 들어 모델 팩토리를 사용해 사용자를 생성한 뒤 바로 인증시킬 수 있습니다.

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에 전달된 가드는 해당 테스트가 실행되는 동안 기본 가드로도 사용됩니다.

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

요청이 인증되지 않은 상태임을 보장하고 싶다면 actingAsGuest 메서드를 사용할 수 있습니다.

$this->actingAsGuest();

응답 디버깅하기

애플리케이션에 테스트 요청을 보낸 뒤, dump, dumpHeaders, dumpSession 메서드를 사용해 응답 내용을 확인하고 디버깅할 수 있습니다.

Pest

<?php

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

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

PHPUnit

<?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->dump();
        $response->dumpHeaders();
        $response->dumpSession();
    }
}

또는 dd, ddHeaders, ddBody, ddJson, ddSession 메서드를 사용하면 응답 정보를 출력한 뒤 실행을 즉시 중단시킬 수 있습니다.

Pest

<?php

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

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

PHPUnit

<?php

namespace Tests\Feature;

use Tests\TestCase;

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

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

예외 처리

애플리케이션이 특정 예외를 제대로 던지는지 테스트해야 할 때가 있습니다. 이럴 때는 Exceptions 파사드를 통해 예외 핸들러를 "페이크(fake)"로 만들 수 있습니다. 예외 핸들러를 페이크로 만든 후에는 assertReported, assertNotReported 메서드를 사용해 요청 처리 중 발생한 예외에 대한 검증을 수행할 수 있습니다.

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
{
    /**
     * A basic test example.
     */
    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 메서드는 각각 특정 예외가 발생하지 않았는지, 또는 어떤 예외도 전혀 발생하지 않았는지를 검증할 때 사용합니다.

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

요청을 보내기 전에 withoutExceptionHandling 메서드를 호출하면 해당 요청에 대해 예외 처리를 완전히 비활성화할 수 있습니다.

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

또한 애플리케이션이 PHP 언어나 사용 중인 라이브러리에서 지원 중단(deprecated)된 기능을 사용하고 있지는 않은지 확인하고 싶다면, 요청을 보내기 전에 withoutDeprecationHandling 메서드를 호출하면 됩니다. 지원 중단 경고 처리가 비활성화되면 지원 중단 경고가 예외로 변환되어 해당 테스트가 실패하게 됩니다.

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

assertThrows 메서드를 사용하면 주어진 클로저 안의 코드가 지정한 타입의 예외를 던지는지 검증할 수 있습니다.

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

던져진 예외를 직접 검사하고 그에 대한 추가 검증을 하고 싶다면, assertThrows 메서드의 두 번째 인수로 클로저를 전달하면 됩니다.

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

assertDoesntThrow 메서드는 주어진 클로저 안의 코드가 어떤 예외도 던지지 않는지 검증할 때 사용합니다.

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

JSON API 테스트하기

Laravel은 JSON API와 그 응답을 테스트할 수 있는 다양한 헬퍼도 제공합니다. json, getJson, postJson, putJson, patchJson, deleteJson, optionsJson 메서드를 사용하면 각 HTTP 메서드에 맞는 JSON 요청을 손쉽게 보낼 수 있습니다. 이 메서드들에는 데이터와 헤더도 간편하게 전달할 수 있습니다. 먼저 /api/user에 POST 요청을 보내고 예상한 JSON 데이터가 반환되는지 확인하는 테스트를 작성해 보겠습니다.

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
{
    /**
     * 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 응답 안의 개별 값을 확인하기가 매우 편리합니다.

Pest

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

PHPUnit

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

NOTE

assertJson 메서드는 응답을 배열로 변환한 뒤, 애플리케이션이 반환한 JSON 응답 안에 주어진 배열이 포함되어 있는지 확인합니다. 따라서 JSON 응답에 다른 속성이 더 있더라도, 지정한 부분(fragment)만 포함되어 있으면 테스트는 통과합니다.

JSON 완전 일치 검증하기

앞서 설명했듯이 assertJson 메서드는 JSON 응답 안에 특정 부분이 존재하는지 확인하는 용도입니다. 만약 애플리케이션이 반환한 JSON이 주어진 배열과 정확히 일치하는지 검증하고 싶다면 assertExactJson 메서드를 사용해야 합니다.

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
{
    /**
     * 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 경로(Path) 검증하기

JSON 응답의 특정 경로에 지정한 데이터가 존재하는지 확인하고 싶다면 assertJsonPath 메서드를 사용하세요.

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
{
    /**
     * A basic functional test example.
     */
    public function test_asserting_a_json_paths_value(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);

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

assertJsonPath 메서드는 클로저도 받을 수 있으며, 이를 활용해 검증 통과 여부를 동적으로 판단할 수 있습니다.

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

여러 JSON 경로를 한 번에 검증하고 싶다면 assertJsonPaths 메서드를 사용하면 됩니다. 각 경로에 대한 기대값으로 클로저를 지정할 수도 있습니다.

$response->assertJsonPaths([
    'team.owner.name' => 'Darian',
    'team.owner.email' => fn (string $email) => str($email)->is('*@laravel.com'),
    'team.members.0.name' => 'Sally',
]);

응답에 여러 JSON 경로가 존재하지 않음을 검증하려면 assertJsonMissingPaths 메서드를 사용할 수 있습니다.

$response->assertJsonMissingPaths([
    'team.owner.password',
    'team.members.0.api_token',
]);

플루언트(Fluent) JSON 테스트

Laravel은 애플리케이션의 JSON 응답을 플루언트하게, 즉 메서드 체이닝 방식으로 우아하게 테스트할 수 있는 기능도 제공합니다. 사용 방법은 assertJson 메서드에 클로저를 전달하는 것입니다. 이 클로저는 Illuminate\Testing\Fluent\AssertableJson 인스턴스를 인자로 받으며, 이를 이용해 애플리케이션이 반환한 JSON에 대한 검증을 수행할 수 있습니다. where 메서드는 JSON의 특정 속성 값을 검증할 때, missing 메서드는 특정 속성이 존재하지 않음을 검증할 때 사용합니다.

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;

/**
 * A basic functional test example.
 */
public function test_fluent_json(): void
{
    $response = $this->getJson('/users/1');

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

`etc` 메서드 이해하기

위 예제 마지막에서 검증 체인 끝에 etc 메서드를 호출한 것을 확인했을 것입니다. 이 메서드는 JSON 객체에 명시적으로 검증하지 않은 다른 속성들이 더 존재할 수 있음을 Laravel에게 알려주는 역할을 합니다. etc 메서드를 호출하지 않으면, 검증하지 않은 속성이 JSON 객체에 남아 있을 경우 테스트가 실패합니다.

이런 동작 방식이 존재하는 이유는, 개발자가 JSON 응답에 민감한 정보를 실수로 노출하지 않도록 하기 위함입니다. 즉, 각 속성에 대해 명시적으로 검증을 작성하거나, 아니면 etc 메서드를 통해 추가 속성이 있음을 명시적으로 허용하도록 강제하는 것입니다.

다만 한 가지 주의할 점이 있습니다. 검증 체인에 etc 메서드를 포함하지 않았다고 해서, JSON 객체 안에 중첩된 배열에까지 추가 속성이 없다는 것을 보장하지는 않습니다. etc 메서드는 그 메서드가 호출된 중첩 단계(nesting level)에서만 추가 속성이 없음을 보장합니다.

속성 존재 여부 검증하기

특정 속성이 존재하는지, 혹은 존재하지 않는지 검증하려면 has와 missing 메서드를 사용하세요.

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

또한 hasAll과 missingAll 메서드를 사용하면 여러 속성의 존재 여부를 한 번에 검증할 수 있습니다.

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

주어진 속성 목록 중 최소 하나라도 존재하는지 확인하려면 hasAny 메서드를 사용할 수 있습니다.

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

JSON 컬렉션 검증하기

라우트가 여러 명의 사용자 정보처럼 다수의 항목이 담긴 JSON 응답을 반환하는 경우가 많습니다.

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

이런 경우에는 플루언트 JSON 객체의 has 메서드를 사용해 응답에 포함된 사용자 목록을 검증할 수 있습니다. 예를 들어 JSON 응답에 사용자가 3명 포함되어 있는지 검증해 보겠습니다. 이어서 first 메서드를 사용해 컬렉션의 첫 번째 사용자에 대한 검증도 진행합니다. first 메서드는 클로저를 인자로 받으며, 이 클로저는 JSON 컬렉션의 첫 번째 객체를 검증할 수 있는 또 다른 assertable JSON 인스턴스를 전달받습니다.

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

JSON 컬렉션의 모든 항목에 대해 동일한 검증을 적용하고 싶다면 each 메서드를 사용하면 됩니다.

$response
  ->assertJson(fn (AssertableJson $json) =>
      $json->has(3)
          ->each(fn (AssertableJson $json) =>
              $json->whereType('id', 'integer')
                  ->whereType('name', 'string')
                  ->whereType('email', 'string')
                  ->missing('password')
                  ->etc()
          )
  );

JSON 컬렉션 검증 범위 지정하기

애플리케이션 라우트 중에는 이름이 붙은 키(named key)에 JSON 컬렉션을 담아 반환하는 경우도 있습니다.

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

이런 라우트를 테스트할 때는 has 메서드로 컬렉션의 항목 개수를 검증할 수 있습니다. 뿐만 아니라 has 메서드를 사용해 이어지는 검증들의 범위(scope)를 지정할 수도 있습니다.

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

하지만 users 컬렉션을 검증하기 위해 has 메서드를 두 번 따로 호출하는 대신, 세 번째 인자로 클로저를 전달하는 한 번의 호출로도 같은 결과를 얻을 수 있습니다. 이렇게 하면 클로저는 자동으로 호출되며, 컬렉션의 첫 번째 항목으로 범위가 지정됩니다.

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

JSON 타입 검증하기

경우에 따라서는 JSON 응답에 포함된 속성 값 자체보다는 해당 속성이 특정 타입인지만 검증하고 싶을 수 있습니다. Illuminate\Testing\Fluent\AssertableJson 클래스는 이를 위해 whereType과 whereAllType 메서드를 제공합니다.

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

whereType 메서드의 두 번째 인자에 | 문자로 구분된 문자열이나 타입 배열을 전달하면 여러 타입을 동시에 지정할 수 있습니다. 응답 값이 나열된 타입 중 하나라도 일치하면 검증이 성공합니다.

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

whereType과 whereAllType 메서드는 string, integer, double, boolean, array, null 타입을 인식합니다.

HTTP 테스트

Illuminate\Http\UploadedFile 클래스는 테스트용 더미 파일이나 이미지를 생성할 수 있는 fake 메서드를 제공합니다. 이 메서드를 Storage 파사드의 fake 메서드와 함께 사용하면 파일 업로드 테스트를 매우 쉽게 작성할 수 있습니다. 예를 들어, 이 두 기능을 조합하면 아바타 업로드 폼을 다음과 같이 간단히 테스트할 수 있습니다:

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

NOTE

Storage::fake()는 실제 디스크에 파일을 쓰지 않는 "가짜" 스토리지 디스크를 생성합니다. 테스트가 끝나면 자동으로 정리되므로, 테스트 실행 중에 storage/app 디렉터리가 실제 파일로 지저분해질 걱정을 하지 않아도 됩니다.

특정 파일이 존재하지 않아야 함을 검증하고 싶다면, Storage 파사드가 제공하는 assertMissing 메서드를 사용하면 됩니다:

Storage::fake('avatars');

// ...

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

가짜 파일 커스터마이징

UploadedFile 클래스의 fake 메서드로 파일을 생성할 때, 이미지의 너비, 높이, 그리고 크기(킬로바이트 단위)를 지정할 수 있습니다. 이를 활용하면 애플리케이션의 검증 규칙을 더욱 꼼꼼하게 테스트할 수 있습니다:

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

이미지뿐만 아니라 create 메서드를 사용하면 다른 형식의 파일도 생성할 수 있습니다:

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

필요하다면 $mimeType 인자를 전달하여 해당 파일이 반환해야 할 MIME 타입을 명시적으로 지정할 수도 있습니다:

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

가령 이미지 업로드 폼에서 PDF 파일이 거부되는지 검증하고 싶을 때, MIME 타입을 application/pdf로 지정한 가짜 파일을 만들어 실제 PDF 업로드처럼 보이게 테스트할 수 있습니다.

뷰 테스트하기

Laravel에서는 애플리케이션에 실제 HTTP 요청을 보내지 않고도 뷰를 렌더링해 테스트할 수 있습니다. 테스트 코드에서 view 메서드를 호출하면 되는데, 이 메서드는 뷰 이름과 (선택적으로) 데이터 배열을 인자로 받습니다. 반환되는 Illuminate\Testing\TestView 인스턴스는 뷰의 출력 내용을 편리하게 검증할 수 있는 여러 어서션 메서드를 제공합니다:

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

필요하다면 TestView 인스턴스를 문자열로 캐스팅해서 렌더링된 원본 뷰 내용을 그대로 가져올 수도 있습니다:

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

에러 공유하기

일부 뷰는 Laravel이 제공하는 전역 에러 백(error bag)에 공유된 에러 정보에 의존하는 경우가 있습니다. 이럴 때는 withViewErrors 메서드를 사용해서 에러 메시지를 미리 채워둘 수 있습니다:

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

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

NOTE

검증 에러 메시지 자체는 실제 서비스에서 한글로 표시되겠지만, 테스트 코드에서는 프레임워크 동작 검증이 목적이므로 예시와 같이 임의의 문자열을 사용해도 무방합니다.

Blade와 컴포넌트 렌더링하기

필요한 경우 blade 메서드를 사용해 순수 Blade 문자열을 평가하고 렌더링할 수 있습니다. view 메서드와 마찬가지로 blade 메서드도 Illuminate\Testing\TestView 인스턴스를 반환합니다:

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

$view->assertSee('Taylor');

Blade 컴포넌트를 직접 평가하고 렌더링하려면 component 메서드를 사용하면 됩니다. 이 메서드는 Illuminate\Testing\TestComponent 인스턴스를 반환합니다:

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

$view->assertSee('Taylor');

라우트 캐싱

테스트를 실행할 때마다 Laravel은 애플리케이션의 새 인스턴스를 부팅하는데, 이 과정에서 정의된 모든 라우트를 다시 수집합니다. 프로젝트에 라우트 파일이 많다면 이 라우트 수집 작업이 테스트 실행 시간에 은근히 영향을 줄 수 있습니다.

이럴 때는 테스트 케이스에 Illuminate\Foundation\Testing\WithCachedRoutes 트레이트를 추가해보세요. 이 트레이트를 사용하면 라우트를 최초 한 번만 빌드해서 메모리에 저장해두고, 이후 테스트 스위트 내의 모든 테스트에서 이를 재사용합니다. 즉, 라우트 수집 과정이 전체 테스트 실행 중 단 한 번만 일어나게 되는 것입니다.

Pest

<?php

use App\Http\Controllers\UserController;
use Illuminate\Foundation\Testing\WithCachedRoutes;

pest()->use(WithCachedRoutes::class);

test('basic example', function () {
    $this->get(action([UserController::class, 'index']));

    // ...
});

PHPUnit

<?php

namespace Tests\Feature;

use App\Http\Controllers\UserController;
use Illuminate\Foundation\Testing\WithCachedRoutes;
use Tests\TestCase;

class BasicTest extends TestCase
{
    use WithCachedRoutes;

    /**
     * A basic functional test example.
     */
    public function test_basic_example(): void
    {
        $response = $this->get(action([UserController::class, 'index']));

        // ...
    }
}

NOTE

라우트 구성이 테스트 도중에 동적으로 바뀌지 않는 프로젝트에서 사용하는 것이 안전합니다. 만약 테스트마다 다른 라우트 설정을 필요로 한다면 이 트레이트를 사용하지 않는 것이 좋습니다.

사용 가능한 Assertion

응답 Assertion

Laravel의 Illuminate\Testing\TestResponse 클래스는 애플리케이션을 테스트할 때 활용할 수 있는 다양한 커스텀 assertion 메서드를 제공합니다. 이 assertion들은 json, get, post, put, delete 등의 테스트 메서드가 반환하는 응답 객체에서 바로 사용할 수 있습니다.

assertAccepted assertBadRequest assertClientError assertConflict assertCookie assertCookieExpired assertCookieNotExpired assertCookieMissing assertCreated assertDontSee assertDontSeeText assertDownload assertExactJson assertExactJsonStructure assertFailedDependency assertForbidden assertFound assertGone assertHeader assertHeaderContains assertHeaderMissing assertInternalServerError assertJson assertJsonCount assertJsonFragment assertJsonIsArray assertJsonIsObject assertJsonMissing assertJsonMissingExact assertJsonMissingValidationErrors assertJsonPath assertJsonPaths assertJsonMissingPath assertJsonMissingPaths assertJsonStructure assertJsonValidationErrors assertJsonValidationErrorFor assertLocation assertMethodNotAllowed assertMovedPermanently assertContent assertNoContent assertStreamed assertStreamedContent assertNotFound assertOk assertPaymentRequired assertPlainCookie assertRedirect assertRedirectBack assertRedirectBackWithErrors assertRedirectBackWithoutErrors assertRedirectContains assertRedirectToRoute assertRedirectToSignedRoute assertRequestTimeout assertSee assertSeeInOrder assertSeeText assertSeeTextInOrder assertServerError assertServiceUnavailable assertSessionHas assertSessionHasInput assertSessionHasAll assertSessionHasErrors assertSessionHasErrorsIn assertSessionHasNoErrors assertSessionDoesntHaveErrors assertSessionMissing assertSessionMissingInput assertStatus assertSuccessful assertTooManyRequests assertUnauthorized assertUnprocessable assertUnsupportedMediaType assertValid assertInvalid assertViewHas assertViewHasAll assertViewIs assertViewMissing

assertAccepted

응답의 HTTP 상태 코드가 accepted(202)인지 확인합니다:

$response->assertAccepted();

응답의 HTTP 상태 코드가 bad request(400)인지 확인합니다:

$response->assertBadRequest();

응답의 HTTP 상태 코드가 클라이언트 에러(400 이상 500 미만)인지 확인합니다:

$response->assertClientError();

응답의 HTTP 상태 코드가 conflict(409)인지 확인합니다:

$response->assertConflict();

응답에 주어진 쿠키가 포함되어 있는지 확인합니다:

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

assertCookieExpired

응답에 주어진 쿠키가 포함되어 있고, 만료되었는지 확인합니다:

$response->assertCookieExpired($cookieName);

assertCookieNotExpired

응답에 주어진 쿠키가 포함되어 있고, 만료되지 않았는지 확인합니다:

$response->assertCookieNotExpired($cookieName);

assertCookieMissing

응답에 주어진 쿠키가 포함되어 있지 않은지 확인합니다:

$response->assertCookieMissing($cookieName);

assertCreated

응답의 HTTP 상태 코드가 201인지 확인합니다:

$response->assertCreated();

assertDontSee

애플리케이션이 반환한 응답에 주어진 문자열이 포함되어 있지 않은지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다:

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

assertDontSeeText

응답 텍스트에 주어진 문자열이 포함되어 있지 않은지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다. 이 메서드는 assertion을 수행하기 전에 응답 콘텐츠를 PHP의 strip_tags 함수에 통과시킵니다:

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

assertDownload

응답이 "다운로드" 응답인지 확인합니다. 일반적으로 이는 호출된 라우트가 Response::download 응답, BinaryFileResponse, 또는 Storage::download 응답을 반환했음을 의미합니다:

$response->assertDownload();

필요하다면 다운로드되는 파일에 지정된 파일명이 부여되었는지도 확인할 수 있습니다:

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

assertExactJson

응답에 주어진 JSON 데이터와 정확히 일치하는 데이터가 포함되어 있는지 확인합니다:

$response->assertExactJson(array $data);

assertExactJsonStructure

응답에 주어진 JSON 구조와 정확히 일치하는 구조가 포함되어 있는지 확인합니다:

$response->assertExactJsonStructure(array $data);

이 메서드는 assertJsonStructure보다 더 엄격한 버전입니다. assertJsonStructure와 달리, 예상 JSON 구조에 명시되지 않은 키가 응답에 하나라도 포함되어 있으면 실패합니다.

assertFailedDependency

응답의 HTTP 상태 코드가 failed dependency(424)인지 확인합니다:

$response->assertFailedDependency();

assertForbidden

응답의 HTTP 상태 코드가 forbidden(403)인지 확인합니다:

$response->assertForbidden();

assertFound

응답의 HTTP 상태 코드가 found(302)인지 확인합니다:

$response->assertFound();

assertGone

응답의 HTTP 상태 코드가 gone(410)인지 확인합니다:

$response->assertGone();

assertHeader

응답에 주어진 헤더와 값이 존재하는지 확인합니다:

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

assertHeaderContains

주어진 헤더에 특정 부분 문자열 값이 포함되어 있는지 확인합니다:

$response->assertHeaderContains($headerName, $value);

assertHeaderMissing

응답에 주어진 헤더가 존재하지 않는지 확인합니다:

$response->assertHeaderMissing($headerName);

assertInternalServerError

응답의 HTTP 상태 코드가 "Internal Server Error"(500)인지 확인합니다:

$response->assertInternalServerError();

assertJson

응답에 주어진 JSON 데이터가 포함되어 있는지 확인합니다:

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

assertJson 메서드는 응답을 배열로 변환하여, 애플리케이션이 반환한 JSON 응답 안에 주어진 배열이 존재하는지 검증합니다. 따라서 JSON 응답에 다른 속성이 더 있더라도, 주어진 데이터 조각이 포함되어 있기만 하면 이 테스트는 통과합니다.

assertJsonCount

응답 JSON의 지정된 키에 있는 배열이 예상한 개수의 항목을 가지고 있는지 확인합니다:

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

assertJsonFragment

응답 어딘가에 주어진 JSON 데이터가 포함되어 있는지 확인합니다:

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

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

assertJsonIsArray

응답 JSON이 배열인지 확인합니다:

$response->assertJsonIsArray();

assertJsonIsObject

응답 JSON이 객체인지 확인합니다:

$response->assertJsonIsObject();

assertJsonMissing

응답에 주어진 JSON 데이터가 포함되어 있지 않은지 확인합니다:

$response->assertJsonMissing(array $data);

assertJsonMissingExact

응답에 주어진 JSON 데이터와 정확히 일치하는 데이터가 포함되어 있지 않은지 확인합니다:

$response->assertJsonMissingExact(array $data);

assertJsonMissingValidationErrors

응답에 주어진 키들에 대한 JSON 유효성 검증 오류가 없는지 확인합니다:

$response->assertJsonMissingValidationErrors($keys);

NOTE

좀 더 범용적인 assertValid 메서드를 사용하면, 응답에 JSON으로 반환된 유효성 검증 오류가 없는 것과 세션에 플래시된 오류가 없는 것을 동시에 확인할 수 있습니다.

assertJsonPath

지정된 경로에 주어진 데이터가 응답에 포함되어 있는지 확인합니다:

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

예를 들어, 애플리케이션이 다음과 같은 JSON 응답을 반환한다고 가정해봅시다:

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

다음과 같이 user 객체의 name 속성이 주어진 값과 일치하는지 확인할 수 있습니다:

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

assertJsonPaths

지정된 여러 경로에 주어진 데이터가 응답에 포함되어 있는지 확인합니다:

$response->assertJsonPaths(array $paths);

예를 들어, 응답 안의 여러 값을 한 번에 확인할 수 있습니다:

$response->assertJsonPaths([
    'user.name' => 'Steve Schoger',
    'user.email' => fn (string $email) => str($email)->endsWith('@laravel.com'),
]);

assertJsonMissingPath

응답에 주어진 경로가 포함되어 있지 않은지 확인합니다:

$response->assertJsonMissingPath($path);

예를 들어, 애플리케이션이 다음과 같은 JSON 응답을 반환한다고 가정해봅시다:

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

다음과 같이 user 객체에 email 속성이 없는지 확인할 수 있습니다:

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

assertJsonMissingPaths

응답에 주어진 경로들이 포함되어 있지 않은지 확인합니다:

$response->assertJsonMissingPaths($paths);

예를 들어, 여러 경로가 응답에서 누락되어 있는지 한 번에 확인할 수 있습니다:

$response->assertJsonMissingPaths([
    'user.email',
    'user.password',
]);

assertJsonStructure

응답이 주어진 JSON 구조를 가지고 있는지 확인합니다:

$response->assertJsonStructure(array $structure);

예를 들어, 애플리케이션이 반환하는 JSON 응답이 다음과 같은 데이터를 포함한다고 가정해봅시다:

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

다음과 같이 JSON 구조가 예상과 일치하는지 확인할 수 있습니다:

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

경우에 따라 애플리케이션이 반환하는 JSON 응답에 객체 배열이 포함될 수도 있습니다:

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

이런 경우 * 문자를 사용하여 배열 안 모든 객체의 구조를 한 번에 검증할 수 있습니다:

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

assertJsonValidationErrors

응답에 주어진 키에 대한 JSON 유효성 검증 오류가 있는지 확인합니다. 이 메서드는 유효성 검증 오류가 세션에 플래시되는 대신 JSON 구조로 반환되는 응답을 테스트할 때 사용해야 합니다:

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

NOTE

좀 더 범용적인 assertInvalid 메서드를 사용하면, 응답에 JSON으로 반환된 유효성 검증 오류가 있는지나 세션에 오류가 플래시되었는지를 함께 확인할 수 있습니다.

assertJsonValidationErrorFor

주어진 키에 대한 JSON 유효성 검증 오류가 존재하는지 확인합니다:

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

assertMethodNotAllowed

응답의 HTTP 상태 코드가 method not allowed(405)인지 확인합니다:

$response->assertMethodNotAllowed();

assertMovedPermanently

응답의 HTTP 상태 코드가 moved permanently(301)인지 확인합니다:

$response->assertMovedPermanently();

assertLocation

응답의 Location 헤더에 주어진 URI 값이 들어있는지 확인합니다:

$response->assertLocation($uri);

assertContent

주어진 문자열이 응답 콘텐츠와 일치하는지 확인합니다:

$response->assertContent($value);

assertNoContent

응답이 주어진 HTTP 상태 코드를 가지고 있고, 콘텐츠가 없는지 확인합니다:

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

assertStreamed

응답이 스트리밍 응답인지 확인합니다:

$response->assertStreamed();

assertStreamedContent

주어진 문자열이 스트리밍 응답 콘텐츠와 일치하는지 확인합니다:

$response->assertStreamedContent($value);

응답의 HTTP 상태 코드가 not found(404)인지 확인합니다:

$response->assertNotFound();

assertOk

응답의 HTTP 상태 코드가 200인지 확인합니다:

$response->assertOk();

assertPaymentRequired

응답의 HTTP 상태 코드가 payment required(402)인지 확인합니다:

$response->assertPaymentRequired();

assertPlainCookie

응답에 주어진 암호화되지 않은 쿠키가 포함되어 있는지 확인합니다:

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

assertRedirect

응답이 주어진 URI로 리다이렉트하는지 확인합니다:

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

assertRedirectBack

응답이 이전 페이지로 다시 리다이렉트하는지 확인합니다:

$response->assertRedirectBack();

assertRedirectBackWithErrors

응답이 이전 페이지로 다시 리다이렉트하면서 세션에 주어진 오류가 포함되어 있는지 확인합니다:

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

assertRedirectBackWithoutErrors

응답이 이전 페이지로 다시 리다이렉트하면서 세션에 오류 메시지가 전혀 없는지 확인합니다:

$response->assertRedirectBackWithoutErrors();

assertRedirectContains

응답이 주어진 문자열을 포함하는 URI로 리다이렉트하는지 확인합니다:

$response->assertRedirectContains($string);

assertRedirectToRoute

응답이 주어진 이름이 있는 라우트로 리다이렉트하는지 확인합니다:

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

assertRedirectToSignedRoute

응답이 주어진 서명된 라우트로 리다이렉트하는지 확인합니다:

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

assertRequestTimeout

응답의 HTTP 상태 코드가 request timeout(408)인지 확인합니다:

$response->assertRequestTimeout();

assertSee

응답에 주어진 문자열이 포함되어 있는지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다:

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

assertSeeInOrder

주어진 문자열들이 응답 안에서 순서대로 포함되어 있는지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다:

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

assertSeeText

응답 텍스트에 주어진 문자열이 포함되어 있는지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다. assertion을 수행하기 전에 응답 콘텐츠는 PHP의 strip_tags 함수에 통과됩니다:

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

assertSeeTextInOrder

주어진 문자열들이 응답 텍스트 안에서 순서대로 포함되어 있는지 확인합니다. 두 번째 인자로 false를 전달하지 않으면 문자열을 자동으로 이스케이프 처리합니다. assertion을 수행하기 전에 응답 콘텐츠는 PHP의 strip_tags 함수에 통과됩니다:

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

assertServerError

응답의 HTTP 상태 코드가 서버 에러(500 이상 600 미만)인지 확인합니다:

$response->assertServerError();

assertServiceUnavailable

응답의 HTTP 상태 코드가 "Service Unavailable"(503)인지 확인합니다:

$response->assertServiceUnavailable();

assertSessionHas

세션에 주어진 데이터가 포함되어 있는지 확인합니다:

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

필요하다면 두 번째 인자로 클로저를 전달할 수 있습니다. 이 클로저가 true를 반환하면 assertion이 통과합니다:

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

assertSessionHasInput

세션의 플래시된 입력값 배열에 주어진 값이 있는지 확인합니다:

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

필요하다면 assertSessionHasInput 메서드의 두 번째 인자로 클로저를 전달할 수 있습니다. 이 클로저가 true를 반환하면 assertion이 통과합니다:

use Illuminate\Support\Facades\Crypt;

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

assertSessionHasAll

세션에 주어진 키/값 쌍의 배열이 모두 포함되어 있는지 확인합니다:

$response->assertSessionHasAll(array $data);

예를 들어, 애플리케이션 세션에 name과 status 키가 있다면, 다음과 같이 두 값이 모두 존재하고 지정한 값과 일치하는지 확인할 수 있습니다:

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

assertSessionHasErrors

세션에 주어진 $keys에 대한 오류가 포함되어 있는지 확인합니다. $keys가 연관 배열이라면, 각 필드(키)에 대해 특정 오류 메시지(값)가 세션에 포함되어 있는지 확인합니다. 이 메서드는 유효성 검증 오류가 JSON 구조로 반환되는 대신 세션에 플래시되는 라우트를 테스트할 때 사용해야 합니다:

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

예를 들어, name과 email 필드에 대한 유효성 검증 오류 메시지가 세션에 플래시되었는지 확인하려면 다음과 같이 assertSessionHasErrors 메서드를 호출하면 됩니다:

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

또는 특정 필드에 대해 특정 유효성 검증 오류 메시지가 있는지도 확인할 수 있습니다:

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

NOTE

assertSessionHasErrorsIn

특정 에러 백 안에서, 세션에 주어진 $keys에 대한 오류가 포함되어 있는지 확인합니다. $keys가 연관 배열이라면, 에러 백 안에서 각 필드(키)에 대해 특정 오류 메시지(값)가 포함되어 있는지 확인합니다:

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

assertSessionHasNoErrors

세션에 유효성 검증 오류가 전혀 없는지 확인합니다:

$response->assertSessionHasNoErrors();

assertSessionDoesntHaveErrors

세션에 주어진 키들에 대한 유효성 검증 오류가 없는지 확인합니다:

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

NOTE

assertSessionMissing

세션에 주어진 키가 포함되어 있지 않은지 확인합니다:

$response->assertSessionMissing($key);

assertSessionMissingInput

플래시된 입력값 배열에 주어진 입력 키가 없는지 확인합니다:

$response->assertSessionMissingInput($key);

assertStatus

응답이 주어진 HTTP 상태 코드를 가지고 있는지 확인합니다:

$response->assertStatus($code);

assertSuccessful

응답의 HTTP 상태 코드가 성공(200 이상 300 미만)인지 확인합니다:

$response->assertSuccessful();

assertTooManyRequests

응답의 HTTP 상태 코드가 too many requests(429)인지 확인합니다:

$response->assertTooManyRequests();

assertUnauthorized

응답의 HTTP 상태 코드가 unauthorized(401)인지 확인합니다:

$response->assertUnauthorized();

assertUnprocessable

응답의 HTTP 상태 코드가 unprocessable entity(422)인지 확인합니다:

$response->assertUnprocessable();

assertUnsupportedMediaType

응답의 HTTP 상태 코드가 unsupported media type(415)인지 확인합니다:

$response->assertUnsupportedMediaType();

assertValid

응답에 주어진 키들에 대한 유효성 검증 오류가 없는지 확인합니다. 이 메서드는 유효성 검증 오류가 JSON 구조로 반환되는 경우와 세션에 플래시되는 경우 모두에 사용할 수 있습니다:

// 유효성 검증 오류가 전혀 없는지 확인...
$response->assertValid();

// 주어진 키들에 유효성 검증 오류가 없는지 확인...
$response->assertValid(['name', 'email']);

assertInvalid

응답에 주어진 키들에 대한 유효성 검증 오류가 있는지 확인합니다. 이 메서드는 유효성 검증 오류가 JSON 구조로 반환되는 경우와 세션에 플래시되는 경우 모두에 사용할 수 있습니다:

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

특정 키에 대해 특정 유효성 검증 오류 메시지가 있는지도 확인할 수 있습니다. 이때 메시지 전체를 전달할 수도 있고, 메시지 일부만 전달할 수도 있습니다:

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

주어진 필드들만이 유효성 검증 오류를 가진 유일한 필드인지 확인하고 싶다면 assertOnlyInvalid 메서드를 사용할 수 있습니다:

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

assertViewHas

응답 뷰에 주어진 데이터가 포함되어 있는지 확인합니다:

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

assertViewHas 메서드의 두 번째 인자로 클로저를 전달하면, 특정 뷰 데이터를 확인하고 그에 대한 assertion을 수행할 수 있습니다:

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

또한 뷰 데이터는 응답 객체에서 배열 변수처럼 접근할 수 있어, 손쉽게 확인할 수 있습니다:

Pest

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

PHPUnit

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

assertViewHasAll

응답 뷰가 주어진 목록의 데이터를 가지고 있는지 확인합니다:

$response->assertViewHasAll(array $data);

이 메서드는 주어진 키에 해당하는 데이터가 뷰에 단순히 포함되어 있는지 확인할 때 사용할 수 있습니다:

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

또는 뷰 데이터가 존재하면서 특정 값을 가지고 있는지도 확인할 수 있습니다:

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

assertViewIs

라우트가 주어진 뷰를 반환했는지 확인합니다:

$response->assertViewIs($value);

assertViewMissing

애플리케이션 응답에 포함된 뷰에서 주어진 데이터 키를 사용할 수 없는(전달되지 않은) 상태인지 확인합니다:

$response->assertViewMissing($key);

인증 관련 Assertion

Laravel은 애플리케이션의 기능 테스트에서 활용할 수 있는 다양한 인증 관련 assertion도 제공합니다. 이 메서드들은 get, post 등의 메서드가 반환하는 Illuminate\Testing\TestResponse 인스턴스가 아니라, 테스트 클래스 자체에서 호출한다는 점에 유의하세요.

assertAuthenticated

사용자가 인증되었는지 확인합니다:

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

assertGuest

사용자가 인증되지 않은 상태(게스트)인지 확인합니다:

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

assertAuthenticatedAs

특정 사용자가 인증되었는지 확인합니다:

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

HTTP 테스트

유효성 검사 관련 어서션

라라벨은 요청으로 전달된 데이터가 유효한지 혹은 유효하지 않은지를 검증할 수 있도록 두 가지 핵심 유효성 검사 어서션을 제공합니다.

assertValid

지정한 키에 대한 유효성 검사 오류가 응답에 없는지 확인합니다. 이 메서드는 유효성 검사 오류가 JSON 형태로 반환되는 경우와, 세션에 플래시(flash)되어 전달되는 경우 모두에 사용할 수 있습니다:

// 유효성 검사 오류가 전혀 없는지 확인...
$response->assertValid();

// 주어진 키들에 유효성 검사 오류가 없는지 확인...
$response->assertValid(['name', 'email']);

assertInvalid

지정한 키에 대한 유효성 검사 오류가 응답에 존재하는지 확인합니다. 이 메서드 역시 유효성 검사 오류가 JSON 형태로 반환되는 경우와, 세션에 플래시되어 전달되는 경우 모두에 사용할 수 있습니다:

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

특정 키에 대해 구체적인 유효성 검사 오류 메시지가 포함되어 있는지도 확인할 수 있습니다. 이때 전체 메시지를 전달하거나, 메시지의 일부만 전달해도 됩니다:

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

NOTE

assertValid와 assertInvalid는 각각 유효성 검사가 세션 기반(일반적인 웹 요청)이든 JSON 응답 기반(API 요청)이든 상관없이 동일하게 동작하므로, 별도로 응답 형식을 구분해서 어서션을 작성할 필요가 없습니다.