Community Learn Tools Library Leisure
search
English
Home > PHP Framework > Laravel > How to use model factory in Laravel application?

How to use model factory in Laravel application?

青灯夜游
Release： 2022-11-28 20:26:22
forward
1196 people have browsed it

How to use model factory in Laravel application? The following article will introduce to you how to use Laravel model engineering in testing. I hope it will be helpful to you!

How to use model factory in Laravel application?

#Laravel Model Factory is one of the best features you can use while testing in your application. They provide a way to define data that is predictable and easily replicable so that your tests remain consistent and controllable.

Let's start with a simple example. We have an application for blogging, so naturally we have a Post model that has a status of Published, Drafted, or Queued. Let's take a look at the Eloquent model for this example: 

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',
    ];
}
Copy after login

As you can see here, we have an Enum for the status column, which we will now design. Using enums here allows us to take advantage of PHP 8.1 features instead of plain strings, boolean flags, or confusing database enums. 

 declare(strict_types=1);

namespace App\Publishing\Enums;

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

Now, let’s get back to the topic we’re discussing here: Model Factory. A simple factory looks simple: 

 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,
        ];
    }
}
Copy after login

So in our tests we can now quickly call our post factory to create a post for us. Let's see how we can do this: 

 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');
});
Copy after login
Copy after login

A simple enough test, but what happens if our business rules state that you can only update specific columns based on post type? Let's refactor our test to make sure we can do this: 

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');
});
Copy after login

Perfectly, we can pass a parameter to the create method to make sure we set the correct type when we create it, so that our The business rules won't complain. But writing it like this is a bit cumbersome, so let's refactor our factory a little and add a method to modify the 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(),
            ],
        );
    }
}
Copy after login

We set a default value for the factory so that all newly created posts are drafts. We then add a method to set the state to publish, which will use the correct Enum value and set the publish date - more predictable and repeatable in a test environment. Let's see what our test looks like now: 

 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');
});
Copy after login
Copy after login

Back to a simple test - so if we have multiple tests that want to create a draft post, they can use a factory. Now let's write a test for the published state to see if there are any errors. 

 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);
});
Copy after login

This time we are testing whether we receive a validation error status when we try to update a published post. This ensures we protect our content and enforce specific workflows within our applications.

So what happens if we also want to ensure specific content in the factory? We can add another method to modify the status if needed: 

 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),
            ],
        );
    }
}
Copy after login

So within our tests we can create a new test to make sure we can update the draft post title via our API: 

 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');
});
Copy after login

So we can use factory state nicely to control things in our test environment, giving us as much control as possible. Doing so will ensure that we are consistently prepared for testing, or that the state of the application at a specific point is well reflected.

What should we do if we need to create many models for our tests? What should we do? The simple answer is to tell the factory: 

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

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

So we are creating 12 new posts and making sure that when we get the index route, we have 12 posts returned. Instead of passing count to the factory method, you can also use the count method: 

Post::factory()->count(12)->create();
Copy after login

However, sometimes in our application we may want to run things in a specific order. Suppose we want the first one to be a draft, but the second one to be published? 

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

How do you use model factories in your application? Have you found any cool ways to use them? Tell us on twitter!

Original address: https://laravel-news.com/laravel-model-factories

Translation address: https://learnku.com/laravel/t/70290

[Related recommendations: laravel video tutorial]

The above is the detailed content of How to use model factory in Laravel application?. For more information, please follow other related articles on the PHP Chinese website!

Related labels：
php laravel
source：learnku.com
Previous article：Performance competition between laravel9 and laravels! Next article：Laravel message prompt extension recommendation: spatie/Laravel-flash
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Latest Issues
PHP arrays obtained from URL parameters do not behave as expected I have a URL parameter that contains the category ID and I want to treat it as an array li...
From 2024-04-06 22:09:02
0
1
1428
Where should I place CustomLog directive in apache I'm using php:7.2-apachedocker. I need to disable health check url login access log. Based...
From 2024-04-06 22:03:59
0
1
990
What is the format of the variables in the return value? I am a new learner of php. I found a piece of code: if($x<time()){return[false,'error']...
From 2024-04-06 21:55:20
0
1
778
Problems encountered when using opentbs to generate odt files: values ​​of the same key are displayed in the same row instead of separate columns. I'm using a library called OpenTbs to create odt using PHP, I'm using it because columns a...
From 2024-04-06 20:18:18
0
1
483
Group MySQL results by ID for looping over I have a table with flight data in mysql. I'm writing a php code that will group and displ...
From 2024-04-06 17:27:56
0
1
406
Related Topics
More>
Popular Recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template