<?php
 
test('应用程序返回成功响应', function () {
    $response = $this->get('/');
 
    $response->assertStatus(200);
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的测试示例。
     */
    public function test_应用程序返回成功响应(): void
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

<?php
 
test('基本请求', function () {
    $response = $this->get('/');
 
    $response->assertStatus(200);
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的测试示例。
     */
    public function test_一个基本请求(): void
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

<?php
 
test('与头交互', function () {
    $response = $this->withHeaders([
        'X-Header' => 'Value',
    ])->post('/user', ['name' => 'Sally']);
 
    $response->assertStatus(201);
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的功能测试示例。
     */
    public function test_与头交互(): void
    {
        $response = $this->withHeaders([
            'X-Header' => 'Value',
        ])->post('/user', ['name' => 'Sally']);
 
        $response->assertStatus(201);
    }
}

<?php
 
test('与 Cookie 交互', function () {
    $response = $this->withCookie('color', 'blue')->get('/');
 
    $response = $this->withCookies([
        'color' => 'blue',
        'name' => 'Taylor',
    ])->get('/');
 
    //
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_与_Cookie_交互(): void
    {
        $response = $this->withCookie('color', 'blue')->get('/');
 
        $response = $this->withCookies([
            'color' => 'blue',
            'name' => 'Taylor',
        ])->get('/');
 
        //
    }
}

<?php
 
test('与会话交互', function () {
    $response = $this->withSession(['banned' => false])->get('/');
 
    //
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_与会话交互(): void
    {
        $response = $this->withSession(['banned' => false])->get('/');
 
        //
    }
}

<?php
 
use App\Models\User;
 
test('需要认证的操作', function () {
    $user = User::factory()->create();
 
    $response = $this->actingAs($user)
                     ->withSession(['banned' => false])
                     ->get('/');
 
    //
});

<?php
 
namespace Tests\Feature;
 
use App\Models\User;
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_需要认证的操作(): void
    {
        $user = User::factory()->create();
 
        $response = $this->actingAs($user)
                         ->withSession(['banned' => false])
                         ->get('/');
 
        //
    }
}

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

<?php
 
test('基本测试', function () {
    $response = $this->get('/');
 
    $response->dumpHeaders();
 
    $response->dumpSession();
 
    $response->dump();
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的测试示例。
     */
    public function test_基本测试(): void
    {
        $response = $this->get('/');
 
        $response->dumpHeaders();
 
        $response->dumpSession();
 
        $response->dump();
    }
}

<?php
 
test('基本测试', function () {
    $response = $this->get('/');
 
    $response->ddHeaders();
 
    $response->ddSession();
 
    $response->dd();
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的测试示例。
     */
    public function test_基本测试(): void
    {
        $response = $this->get('/');
 
        $response->ddHeaders();
 
        $response->ddSession();
 
        $response->dd();
    }
}

<?php
 
use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
 
test('异常被抛出', function () {
    Exceptions::fake();
 
    $response = $this->get('/order/1');
 
    // 断言抛出了异常...
    Exceptions::assertReported(InvalidOrderException::class);
 
    // 对异常进行断言...
    Exceptions::assertReported(function (InvalidOrderException $e) {
        return $e->getMessage() === '订单无效。';
    });
});

<?php
 
namespace Tests\Feature;
 
use App\Exceptions\InvalidOrderException;
use Illuminate\Support\Facades\Exceptions;
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的测试示例。
     */
    public function test_异常被抛出(): void
    {
        Exceptions::fake();
 
        $response = $this->get('/');
 
        // 断言抛出了异常...
        Exceptions::assertReported(InvalidOrderException::class);
 
        // 对异常进行断言...
        Exceptions::assertReported(function (InvalidOrderException $e) {
            return $e->getMessage() === '订单无效。';
        });
    }
}

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

<?php
 
test('发出 API 请求', function () {
    $response = $this->postJson('/api/user', ['name' => 'Sally']);
 
    $response
        ->assertStatus(201)
        ->assertJson([
            'created' => true,
         ]);
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的功能测试示例。
     */
    public function test_发出_API_请求(): void
    {
        $response = $this->postJson('/api/user', ['name' => 'Sally']);
 
        $response
            ->assertStatus(201)
            ->assertJson([
                'created' => true,
            ]);
    }
}

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

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

<?php
 
test('断言精确的 JSON 匹配', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);
 
    $response
        ->assertStatus(201)
        ->assertExactJson([
            'created' => true,
        ]);
});
 

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的功能测试示例。
     */
    public function test_断言精确的_JSON_匹配(): void
    {
        $response = $this->postJson('/user', ['name' => 'Sally']);
 
        $response
            ->assertStatus(201)
            ->assertExactJson([
                'created' => true,
            ]);
    }
}

<?php
 
test('断言 JSON 路径值', function () {
    $response = $this->postJson('/user', ['name' => 'Sally']);
 
    $response
        ->assertStatus(201)
        ->assertJsonPath('team.owner.name', 'Darian');
});

<?php
 
namespace Tests\Feature;
 
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    /**
     * 一个基本的功能测试示例。
     */
    public function test_断言_JSON_路径值(): void
    {
        $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);

use Illuminate\Testing\Fluent\AssertableJson;
 
test('流畅的 JSON', function () {
    $response = $this->getJson('/users/1');
 
    $response
        ->assertJson(fn (AssertableJson $json) =>
            $json->where('id', 1)
                 ->where('name', 'Victoria Faith')
                 ->where('email
#### 理解 `etc` 方法
 
在上述示例中，您可能已经注意到我们在断言链的末尾调用了 `etc` 方法。此方法告知 Laravel，JSON 对象上可能存在其他属性。如果未使用 `etc` 方法，并且 JSON 对象上存在您未进行断言的其他属性，则测试将失败。
 
这种行为的目的是通过强制您要么对属性明确进行断言，要么通过 `etc` 方法明确允许其他属性，从而保护您不会在 JSON 响应中无意地暴露敏感信息。
 
但是，您应该注意，在断言链中不包含 `etc` 方法并不能确保不会向嵌套在 JSON 对象中的数组添加其他属性。`etc` 方法仅确保在调用 `etc` 方法的嵌套级别上不存在其他属性。
 
#### 断言属性的存在/不存在
 
要断言属性是否存在，您可以使用 `has` 和 `missing` 方法：
 
```php
$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()
             )
    );

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

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

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

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

$response->assertBadRequest();

$response->assertAccepted();

$response->assertConflict();

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

$response->assertCookieExpired($cookieName);

$response->assertCookieNotExpired($cookieName);

$response->assertCookieMissing($cookieName);

$response->assertCreated();

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

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

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

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

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

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

$response->assertJsonIsArray();

$response->assertJsonIsObject();

$response->assertJsonMissing(array $data);

$response->assertJson MissingExact(array $data);

$response->assertJson MissingValidationErrors($keys);

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

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

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

$response->assertJson MissingPath($path);

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

$response->assertJson MissingPath('user.email');

$response->assertJsonStructure(array $structure);

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

$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->assertJsonValidationErrors(array $data, $responseKey = 'errors');

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

$response->assertMethodNotAllowed();

$response->assertMovedPermanently();

$response->assertLocation($uri);

$response->assertContent($value);

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

$response->assertStreamedContent($value);

$response->assertNotFound();

$response->assertOk();

$response->assertPaymentRequired();

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

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

$response->assertRedirectContains($string);

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

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

$response->assertRequestTimeout();

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

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

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

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

$response->assertServerError();

$response->assertServiceUnavailable();

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

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

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

use Illuminate\Support\Facades\Crypt;

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

$response->assertSessionHasAll(array $data);

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

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

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

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

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

$response->assertSessionHasNoErrors();

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

$response->assertSession Missing($key);

$response->assertStatus($code);

$response->assertSuccessful();

$response->assertTooManyRequests();

$response->assertUnauthorized();

$response->assertUnprocessable();

$response->assertUnsupportedMediaType();

// 断言不存在验证错误...
$response->assertValid();

// 断言给定的键没有验证错误...
$response->assertValid(['name', 'email']);

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

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

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

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

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

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

$response->assertViewHasAll(array $data);

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

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

$response->assertViewIs($value);

$response->assertView Missing($key);

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