HTTP テスト

<?php

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

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

<?php

namespace Tests\Feature;

use Tests\TestCase;

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

        $response->assertStatus(200);
    }
}

<?php

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

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

<?php

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

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

<?php

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

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

    //
});

<?php

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

    //
});

<?php

use App\Models\User;

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

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

    //
});

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

$this->actingAsGuest();

<?php

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

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

<?php

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

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

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

Exceptions::assertNotReported(InvalidOrderException::class);

Exceptions::assertNothingReported();

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

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

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

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

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

<?php

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

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

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

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

<?php

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

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

<?php

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Storage::fake('avatars');

// ...

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

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

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

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

<?php

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

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

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

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

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

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

$view->assertSee('Taylor');

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

$view->assertSee('Taylor');

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

    // ...
});

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

        // ...
    }
}

$response->assertOk();
$response->assertStatus($code);
$response->assertNoContent($status = 204);

$response->assertCookie($cookieName, $value = null);
$response->assertCookieExpired($cookieName);
$response->assertCookieNotExpired($cookieName);
$response->assertCookieMissing($cookieName);
$response->assertPlainCookie($cookieName, $value = null);

$response->assertSee($value, $escape = true);
$response->assertSeeInOrder(array $values, $escape = true);
$response->assertSeeText($value, $escape = true);
$response->assertSeeTextInOrder(array $values, $escape = true);
$response->assertDontSee($value, $escape = true);
$response->assertDontSeeText($value, $escape = true);
$response->assertContent($value);
$response->assertHeader($headerName, $value = null);
$response->assertHeaderContains($headerName, $value);
$response->assertHeaderMissing($headerName);
$response->assertStreamed();
$response->assertStreamedContent($value);

$response->assertDownload();

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

$response->assertRedirect($uri = null);
$response->assertRedirectBack();
$response->assertRedirectBackWithErrors(
    array $keys = [], $format = null, $errorBag = 'default'
);
$response->assertRedirectBackWithoutErrors();
$response->assertRedirectContains($string);
$response->assertRedirectToRoute($name, $parameters = []);
$response->assertRedirectToSignedRoute($name = null, $parameters = []);
$response->assertLocation($uri);

$response->assertJson(array $data, $strict = false);
$response->assertExactJson(array $data);
$response->assertJsonCount($count, $key = null);
$response->assertJsonMissing(array $data);
$response->assertJsonMissingExact(array $data);
$response->assertJsonIsArray();
$response->assertJsonIsObject();
$response->assertJsonStructure(array $structure);
$response->assertExactJsonStructure(array $data);

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

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

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

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

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

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

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

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

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

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

$response->assertSessionHas($key, $value = null);
$response->assertSessionHasInput($key, $value = null);
$response->assertSessionHasAll(array $data);
$response->assertSessionMissing($key);
$response->assertSessionMissingInput($key);

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

use Illuminate\Support\Facades\Crypt;

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

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

$response->assertSessionHasErrors(
    array $keys = [], $format = null, $errorBag = 'default'
);
$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);
$response->assertSessionHasNoErrors();
$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag = 'default');
$response->assertJsonValidationErrors(array $data, $responseKey = 'errors');
$response->assertJsonValidationErrorFor(string $key, $responseKey = 'errors');
$response->assertJsonMissingValidationErrors($keys);

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

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

// 入力チェックのエラーがまったく無い
$response->assertValid();

// 渡したキーにエラーが無い
$response->assertValid(['name', 'email']);

// 渡したキーにエラーがある
$response->assertInvalid(['name', 'email']);

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

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

$response->assertViewIs($value);
$response->assertViewHas($key, $value = null);
$response->assertViewHasAll(array $data);
$response->assertViewMissing($key);

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

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

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

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

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

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

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

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

// エラーがまったく無い
$response->assertValid();

// 渡したキーにエラーが無い
$response->assertValid(['name', 'email']);

// 渡したキーにエラーがある
$response->assertInvalid(['name', 'email']);

// メッセージも確かめる（全文でも一部でもよい）
$response->assertInvalid([
    'name' => 'The name field is required.',
    'email' => 'valid email address',
]);