Bagaimana untuk menggunakan kilang model dalam aplikasi Laravel?

Bagaimana untuk menggunakan kilang model dalam aplikasi Laravel? Artikel berikut akan memperkenalkan kepada anda cara menggunakan kejuruteraan model Laravel dalam ujian saya harap ia akan membantu anda!

Kilang Model Laravel ialah salah satu ciri terbaik yang boleh anda gunakan untuk ujian dalam aplikasi anda. Mereka menyediakan cara untuk menentukan data yang boleh diramal dan mudah ditiru supaya ujian anda kekal konsisten dan boleh dikawal.

Mari kita mulakan dengan contoh mudah. Kami mempunyai aplikasi untuk membuat blog, jadi sudah tentu kami mempunyai model Post yang mempunyai status Diterbitkan, Draf atau Beratur. Mari kita lihat model Eloquent untuk contoh ini:

declare(strict_types=1);

namespace App\Models;

use App\Publishing\Enums\PostStatus;
use Illuminate\Database\Model;

class Post extends Model
{
    protected $fillable = [
        'title',
        'slug',
        'content',
        'status',
        'published_at',
    ];

    protected $casts = [
        'status' => PostStatus::class,
        'published_at' => 'datetime',
    ];
}

Seperti yang anda lihat di sini, kami mempunyai Enum untuk lajur status, yang kini kami akan reka bentuk. Menggunakan enum di sini membolehkan kami memanfaatkan ciri PHP 8.1 dan bukannya rentetan biasa, bendera boolean atau enum pangkalan data yang mengelirukan.

 declare(strict_types=1);

namespace App\Publishing\Enums;

enum PostStatus: string
{
    case PUBLISHED = 'published';
    case DRAFT = 'draft';
    case QUEUED = 'queued';
}

Sekarang, mari kita kembali kepada topik yang kita bincangkan di sini: Kilang Model. Kilang yang ringkas kelihatan mudah:

 declare(strict_types=1);

namespace Database\Factories;

use App\Models\Post;
use App\Publishing\Enums\PostStatus;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;

class PostFactory extends Factory
{
    protected $model = Post::class;

    public function definition(): array
    {
        $title = $this->faker->sentence();
        $status = Arr::random(PostStatus::cases());

        return [
            'title' => $title,
            'slug' => Str::slug($title),
            'content' => $this->faker->paragraph(),
            'status' => $status->value,
            'published_at' => $status === PostStatus::PUBLISHED
                ? now()
                : null,
        ];
    }
}

Jadi dalam ujian kami, kami kini boleh menghubungi kilang pos kami dengan pantas untuk membuat siaran untuk kami. Mari lihat bagaimana kita boleh melakukan ini:

 it('can update a post', function () {
    $post = Post::factory()->create();

    putJson(
        route('api.posts.update', $post->slug),
        ['content' => 'test content',
    )->assertSuccessful();

    expect(
        $post->refresh()
    )->content->toEqual('test content');
});

Ujian yang cukup mudah, tetapi apakah yang berlaku jika peraturan perniagaan kami menyatakan bahawa anda hanya boleh mengemas kini lajur tertentu berdasarkan jenis siaran? Mari kita memfaktorkan semula ujian kami untuk memastikan kami boleh melakukan ini:

it('can update a post', function () {
    $post = Post::factory()->create([
        'type' => PostStatus::DRAFT->value,
    ]);

    putJson(
        route('api.posts.update', $post->slug),
        ['content' => 'test content',
    )->assertSuccessful();

    expect(
        $post->refresh()
    )->content->toEqual('test content');
});

Secara sempurna, kami boleh menghantar parameter kepada kaedah cipta untuk memastikan kami menetapkan jenis yang betul apabila kami menciptanya, seperti ini Peraturan perniagaan kami tidak akan mengeluh. Tetapi menulis seperti ini agak menyusahkan, jadi mari kita refactor sedikit kilang kami dan tambah kaedah untuk mengubah suai status:

 declare(strict_types=1);

namespace Database\Factories;

use App\Models\Post;
use App\Publishing\Enums\PostStatus;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class PostFactory extends Factory
{
    protected $model = Post::class;

    public function definition(): array
    {
        $title = $this->faker->sentence();

        return [
            'title' => $title,
            'slug' => Str::slug($title),
            'content' => $this->faker->paragraph(),
            'status' => PostStatus::DRAFT->value,
            'published_at' => null,
        ];
    }

    public function published(): static
    {
        return $this->state(
            fn (array $attributes): array => [
                'status' => PostStatus::PUBLISHED->value,
                'published_at' => now(),
            ],
        );
    }
}

Kami menetapkan nilai lalai untuk kilang supaya semua siaran yang baru dibuat adalah draf. Kami kemudian menambah kaedah untuk menetapkan keadaan untuk diterbitkan, yang akan menggunakan nilai Enum yang betul dan menetapkan tarikh penerbitan - lebih boleh diramal dan boleh diulang dalam persekitaran ujian. Mari lihat rupa ujian kami sekarang:

 it('can update a post', function () {
    $post = Post::factory()->create();

    putJson(
        route('api.posts.update', $post->slug),
        ['content' => 'test content',
    )->assertSuccessful();

    expect(
        $post->refresh()
    )->content->toEqual('test content');
});

Kembali kepada ujian mudah - jadi jika kami mempunyai berbilang ujian yang ingin membuat draf siaran, mereka boleh menggunakan kilang. Sekarang mari kita tulis ujian untuk keadaan yang diterbitkan untuk melihat sama ada terdapat sebarang ralat.

 it('returns an error when trying to update a published post', function () {
    $post = Post::factory()->published()->create();

    putJson(
        route('api.posts.update', $post->slug),
        ['content' => 'test content',
    )->assertStatus(Http::UNPROCESSABLE_ENTITY());

    expect(
        $post->refresh()
    )->content->toEqual($post->content);
});

Kali ini kami menguji sama ada kami menerima status ralat pengesahan apabila kami cuba mengemas kini siaran yang diterbitkan. Ini memastikan kami melindungi kandungan kami dan menguatkuasakan aliran kerja tertentu dalam aplikasi kami.

Jadi apa yang berlaku jika kita juga ingin memastikan kandungan tertentu di kilang? Kami boleh menambah kaedah lain untuk mengubah suai status jika perlu:

 declare(strict_types=1);

namespace Database\Factories;

use App\Models\Post;
use App\Publishing\Enums\PostStatus;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class PostFactory extends Factory
{
    protected $model = Post::class;

    public function definition(): array
    {
        return [
            'title' => $title = $this->faker->sentence(),
            'slug' => Str::slug($title),
            'content' => $this->faker->paragraph(),
            'status' => PostStatus::DRAFT->value,
            'published_at' => null,
        ];
    }

    public function published(): static
    {
        return $this->state(
            fn (array $attributes): array => [
                'status' => PostStatus::PUBLISHED->value,
                'published_at' => now(),
            ],
        );
    }

    public function title(string $title): static
    {
        return $this->state(
            fn (array $attributes): array => [
                'title' => $title,
                'slug' => Str::slug($title),
            ],
        );
    }
}

Jadi dalam ujian kami, kami boleh membuat ujian baharu untuk memastikan kami boleh mengemas kini draf tajuk siaran melalui API kami:

 it('can update a draft posts title', function () {
    $post = Post::factory()->title('test')->create();

    putJson(
        route('api.posts.update', $post->slug),
        ['title' => 'new title',
    )->assertSuccessful();

    expect(
        $post->refresh()
    )->title->toEqual('new title')->slug->toEqual('new-title');
});

Jadi kami boleh menggunakan keadaan kilang dengan baik untuk mengawal perkara dalam persekitaran ujian kami, memberikan kami kawalan sebanyak mungkin. Melakukannya akan memastikan bahawa kami sentiasa bersedia untuk ujian, atau keadaan aplikasi pada titik tertentu dapat dilihat dengan baik.

Apakah yang perlu kita lakukan jika kita perlu mencipta banyak model untuk ujian kita? Apa yang patut kita buat? Jawapan mudah ialah beritahu kilang:

it('lists all posts', function () {
    Post::factory(12)->create();

    getJson(
        route('api.posts.index'),
    )->assertOk()->assertJson(fn (AssertableJson $json) =>
        $json->has(12)->etc(),
    );
});

Jadi kami mencipta 12 siaran baharu dan memastikan bahawa apabila kami mendapat laluan indeks, kami mempunyai 12 jawatan yang dikembalikan. Daripada meneruskan kiraan kepada kaedah kilang, anda juga boleh menggunakan kaedah kiraan:

Post::factory()->count(12)->create();

Walau bagaimanapun, dalam aplikasi kami, kadangkala kami mungkin mahu menjalankan sesuatu dalam susunan tertentu. Katakan kita mahu yang pertama menjadi draf, tetapi yang kedua diterbitkan?

 it('shows the correct status for the posts', function () {
    Post::factory()
        ->count(2)
        ->state(new Sequence(
            ['status' => PostStatus::DRAFT->value],
            ['status' => PostStatus::PUBLISHED->value],
        ))->create();

    getJson(
        route('api.posts.index'),
    )->assertOk()->assertJson(fn (AssertableJson $json) =>
        $json->where('id', 1)
            ->where('status' PostStatus::DRAFT->value)
            ->etc();
    )->assertJson(fn (AssertableJson $json) =>
        $json->where('id', 2)
            ->where('status' PostStatus::PUBLISHED->value)
            ->etc();
    );
});

Bagaimanakah anda menggunakan kilang model dalam aplikasi anda? Pernahkah anda menemui cara yang menarik untuk menggunakannya? Beritahu kami di twitter!

Alamat asal: https://laravel-news.com/laravel-model-factories

Alamat terjemahan: https://learnku.com/laravel/t/70290

[Cadangan berkaitan: tutorial video laravel]

Atas ialah kandungan terperinci Bagaimana untuk menggunakan kilang model dalam aplikasi Laravel?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!