[10.x] Allow Factory::count() to consume callables to be able to generate randomness during runtime.

[derpoho]

Often one needs some randomness in generating Factories for the development environment. For this case the count method in the Factory Base class should accept a callable in addition to int or null. It's optional to be used by developers and i think it has no breaking changes or follow up problems - at least i cannot think of anything.

What could be done with this addition?

AnyModel::factory()->count(function() {
    return fake()->randomDigitNotNull();
});

AnyModel::factory()->count(fn() => fake()->randomDigitNotNull());

Hope this is of interest!

[taylorotwell]

Do you have maybe a more real-world example? In your original example couldn't you just do ->count(random_int(1, 10))?

[taylorotwell]

Thanks for your pull request to Laravel!

Unfortunately, I'm going to delay merging this code for now. To preserve our ability to adequately maintain the framework, we need to be very careful regarding the amount of code we include.

If possible, please consider releasing your code as a package so that the community can still take advantage of your contributions!

If you feel absolutely certain that this code corrects a bug in the framework, please "@" mention me in a follow-up comment with further explanation so that GitHub will send me a notification of your response.

[derpoho]

@taylorotwell Thanks for your reply! Sure, here is my current use case as a description. I am sure there are more out there. Here is a discussion with some replies which take on this topic too: #36289

I think mainly it solves randomness during development in combination with relationships.

Let's say i want to make a Quiz, which has Sections and those sections have Questions.

Quiz::factory()
    ->has(
        QuizSection::factory()
            ->has(
                factory: QuizQuestion::factory()->count(random_int(1, 10)),
                relationship: 'questions'
            )
            ->count(random_int(1, 10)),
        'sections'
    )
    ->count(4)
    ->create();

This will create 4 Quizzes, all with the same 1-10 amount of sections and those sections with 1-10 amount of questions.
But all quizzes will be the same.

By extending count to take a resolvable function we could delay the count until runtime of the factory::make call. By doing so we can create 4 Quizzes with each random count of sections and those random count of questions. So basically complete randomness. This helps during development, especially if you want this randomness for the interface.

Quiz::factory()
   ->has(
       QuizSection::factory()
           ->has(
               factory: QuizQuestion::factory()->count(fn() => random_int(1, 10)),
               relationship: 'questions'
           )
           ->count(fn() => random_int(1, 10)),
       'sections'
   )
   ->count(4)
   ->create();

I hope this defines the use case better and you see the value in this.

[derpoho]

Do you have maybe a more real-world example? In your original example couldn't you just do ->count(random_int(1, 10))?

@taylorotwell see above for a deeper example/use case.

[woodspire]

@taylorotwell @derpoho It would be really useful for me.

I am using a Factory sequence to alternate between different types of relations.
On the first sequence element, I would like 3 relations. For the next sequence entry, I would like 10. I cannot do that right now.

[WildEgo]

@taylorotwell Thanks for your reply! Sure, here is my current use case as a description. I am sure there are more out there. Here is a discussion with some replies which take on this topic too: #36289

I think mainly it solves randomness during development in combination with relationships.

Let's say i want to make a Quiz, which has Sections and those sections have Questions.

Quiz::factory()
    ->has(
        QuizSection::factory()
            ->has(
                factory: QuizQuestion::factory()->count(random_int(1, 10)),
                relationship: 'questions'
            )
            ->count(random_int(1, 10)),
        'sections'
    )
    ->count(4)
    ->create();

This will create 4 Quizzes, all with the same 1-10 amount of sections and those sections with 1-10 amount of questions. But all quizzes will be the same.

By extending count to take a resolvable function we could delay the count until runtime of the factory::make call. By doing so we can create 4 Quizzes with each random count of sections and those random count of questions. So basically complete randomness. This helps during development, especially if you want this randomness for the interface.

Quiz::factory()
   ->has(
       QuizSection::factory()
           ->has(
               factory: QuizQuestion::factory()->count(fn() => random_int(1, 10)),
               relationship: 'questions'
           )
           ->count(fn() => random_int(1, 10)),
       'sections'
   )
   ->count(4)
   ->create();

I hope this defines the use case better and you see the value in this.

Yeah I ended up having the same requirement today, it's nice to mockup and test some stuff, I manually modified the vendor folder, would be sweet to get this merged honestly

[derpoho]

@taylorotwell is too busy ;) Maybe it will come up some time again.