Dummy - Generate PHP class instances populated with dummy data using Faker

Dummy is a package created by Steve Bauman that can be used to generate PHP class instances populated with dummy data using Faker. This can be really useful in generating instances of any class (not just Eloquent models) with realistic data during testing, when seeding databases or for rapid prototyping.

You can install the package via composer:

composer require directorytree/dummy

Dummy allows you to generate classes with dummy data in two ways:

1. Using the HasFactory Trait directly on the class you would like to generate dummy instances of.
2. Using a separate Factory class, which can give you more control over the dummy data generation process.

Examples of each option can be seen below:

namespace App\Data;
 
use Faker\Generator;
use DirectoryTree\Dummy\HasFactory;
 
class Player
{
    use HasFactory;
 
    /**
     * Create a new player instance.
     */
    public function __construct(
        public string $name,
        public DateTime $dob,
        public string $nationality,
    ) {}
 
    /**
     * Define the factory's default state.
     */
    protected function getFactoryDefinition(Generator $faker): array
    {
        return [
            'name' => $faker->name(),
            'dob' => $faker->dateTimeBetween('1970-01-01', '-16 years'),
            'nationality' => $faker->country(),
        ];
    }
 
    /**
     * Create a new instance of the class using the factory definition.
     */
    protected static function toFactoryInstance(array $attributes): static
    {
        return new static(
            $attributes['name'],
            $attributes['dob'],
            $attributes['nationality'],
        );
    }
}

namespace App\Factories;
 
use App\Data\Player;
use DirectoryTree\Dummy\Factory;
 
class PlayerFactory extends Factory
{
    /**
     * Define the factory's default state.
     */
    protected function definition(): array
    {
        return [
            'name' => $this->faker->name(),
            'dob' => $this->faker->dateTimeBetween('1970-01-01', '-16 years'),
            'nationality' => $this->faker->country(),
        ];
    }
 
    /**
     * Generate a new instance of the class.
     */
    protected function generate(array $attributes): Player
    {
        return new Player(
            $attributes['name'],
            $attributes['dob'],
            $attributes['nationality'],
        );
    }
}

You can then generate dummy instances of your class using the make method

// Using the trait:
$player = Player::factory()->make();
 
// Using the factory class:
$player = PlayerFactory::new()->make();

The package also allows you to:

• Override attributes in your definition
• Generate multiple instances using the count method.
• Allow you to define specific methods to apply modifications of default attributes using Factory states
• Create factory callbacks to perform additional tasks after making a class.
• Use factory sequences to alternate the value of a given attribute for each generated class
• Customize the Collection instances returned when making more than one dummy class.

So in a nutshell, Dummy can complement Laravel's default factory classes by extending support to non-Eloquent classes, offering both trait-based and separate factory class implementations, and providing a fluent API for instance generation. This makes it a versatile tool for generating dummy data across different parts of your application.

Learn more about this package and view the source code on Github.