Is there a good way to utilize configure() function when you need to conditionally add items to a factory in an afterCreating hook

[roni-estein]

This was a hacky solution but it worked, in a way that wouldn't interfere with parallel testing. It's terrible and there must be a better solution...

I was given a factory that was a bit messed up and slow because it was always utilizing $this->faker->image which causes a download. However, for testing, images are only required for a tiny fraction of tests, so it should be isolated in a state, rather than being the default action.

However, I was unable to find a way to get the state to manipulate any class variables since the object is regenerated. Instead i added some static class variables and a naive hash to determine if the configure should fire. It's horrible but it gets the job done.

I ideally I was hoping for the new instance to clone the private/protected variables on the class which we could manipulate with public facing methods to avoid this dance. Is there a better solution? If there isn't, I could try to put together a PR if it would be welcome or happily assist someone else who wanted to run with this.

Thanks.

<?php

namespace Database\Factories;

use App\Models\Order;
use App\Models\Product;
use App\Models\Review;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Collection;

class ReviewFactory extends Factory
{
    private static Collection $keys;
    private $index = null;
    
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = Review::class;
    
    public function __construct($count = null, ?Collection $states = null, ?Collection $has = null, ?Collection $for = null, ?Collection $afterMaking = null, ?Collection $afterCreating = null, $connection = null)
    {
        parent::__construct($count, $states, $has, $for, $afterMaking, $afterCreating, $connection);
        
        static::$keys = collect();
        
    }
    
    public function configure()
    {
        
        return $this->afterCreating(function (Review $review) {
            for ( $i = 0; $i <= $this->faker->numberBetween(0, 3); $i++ ) {
                if ( $this->hasHashedFileFor($review) ) {
                    
                    $image = $this->generateFakeFileFor($review);
                    $review->addMedia($image)->toMediaCollection('review_media');
                }
            }
        });
    }
    
    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'order_id'   => Order::factory(),
            'product_id' => Product::factory(),
            'title'      => $this->faker->sentence($nbWords = 6, $variableNbWords = true),
            'score'      => $this->faker->numberBetween(1, 5),
            'recommend'  => $this->faker->boolean(50),
            'sentiment'  => $this->faker->randomFloat(2, -1.0, 1.0),
            'magnitude'  => $this->faker->randomFloat(2, -1.0, 1.0),
            'body'       => $this->faker->paragraph(rand(2, 5)),
            'published'  => $this->faker->boolean(50),
        ];
    }
    
    public function withFakeImage(?string $name = null): ReviewFactory
    {
        
        return $this->state(function ($attributes) use ($name) {
            static::$keys->push([
                'hash' => $this->createHash($attributes), 'name' => $name ?? $this->faker->word,
            ]);
            return [];
        });
        
    }
    
    
    protected function createHash(array $attributes): string
    {
        return $attributes['title'] . substr($attributes['body'], 0, 15);
    }
    
    protected function hasHashedFileFor(Review $review): bool
    {
        $hashstring = $review->title . substr($review->body, 0, 15);
    
        $index = static::$keys->search(fn ($item) => $item['hash'] === $hashstring);
        
        if(is_int($index)){
            $this->index = $index;
            return true;
        }
        
        return false;
    }
    
    
    protected function generateFakeFileFor(Review $review): UploadedFile
    {
        $fields = static::$keys->pull($this->index);
        
        return UploadedFile::fake()->image($fields['name'].'jpeg');
    }
    
    public function shop(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'product_id' => Product::inRandomOrder()->first(),
            ];
        });
    }
    
    public function published(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'published' => 1,
            ];
        });
    }
    
    public function pending(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'published' => 0,
            ];
        });
    }
    
    public function rejected(): ReviewFactory
    {
        return $this->state(function () {
            return [
                'deleted_at' => now(),
            ];
        });
    }
    
    public function score($score): ReviewFactory
    {
        return $this->state(fn ($attributes) => [
            'score' => $score,
        ]);
    }
}