Merge pull request #3 from DirectoryTree/codex/laravel-factory-parity

Add Laravel factory parity conveniences

Author: stevebauman

src/Factory.php

@@ -9,10 +9,14 @@
 use Illuminate\Container\Container;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Traits\Conditionable;
+use Illuminate\Support\Traits\Macroable;
 
 class Factory
 {
     use Conditionable;
+    use Macroable {
+        __call as macroCall;
+    }
 
     /**
      * The current Faker instance.
@@ -35,7 +39,7 @@ public function __construct(
     /**
      * Get a new dummy factory instance for the given attributes.
      */
-    public static function new(Closure|array $attributes = []): static
+    public static function new(callable|array $attributes = []): static
     {
         return (new static)->state($attributes)->configure();
     }
@@ -83,7 +87,7 @@ protected function collect(array $instances = []): mixed
     /**
      * Get the raw attributes generated by the factory.
      */
-    public function raw(Closure|array $attributes = []): array
+    public function raw(callable|array $attributes = []): array
     {
         if ($this->count === null) {
             return $this->state($attributes)->getExpandedAttributes();
@@ -97,7 +101,7 @@ public function raw(Closure|array $attributes = []): array
     /**
      * Create a collection of classes.
      */
-    public function make(Closure|array $attributes = []): mixed
+    public function make(callable|array $attributes = []): mixed
     {
         if (! empty($attributes)) {
             return $this->state($attributes)->make();
@@ -122,6 +126,42 @@ public function make(Closure|array $attributes = []): mixed
         return $instances;
     }
 
+    /**
+     * Make a single instance of the class.
+     */
+    public function makeOne(callable|array $attributes = []): mixed
+    {
+        return $this->count(null)->make($attributes);
+    }
+
+    /**
+     * Create a collection of classes.
+     */
+    public function makeMany(iterable|int|null $records = null): mixed
+    {
+        $records ??= ($this->count ?? 1);
+
+        $this->count = null;
+
+        if (is_numeric($records)) {
+            $records = array_fill(0, $records, []);
+        }
+
+        return $this->collect(
+            (new Collection($records))->map(function ($record) {
+                return $this->state($record)->make();
+            })->all()
+        );
+    }
+
+    /**
+     * Create a callback that makes the class when invoked.
+     */
+    public function lazy(array $attributes = []): Closure
+    {
+        return fn () => $this->make($attributes);
+    }
+
     /**
      * Make an instance of the class with the given attributes.
      */
@@ -179,17 +219,27 @@ protected function expandAttributes(array $definition): array
     /**
      * Add a new state transformation to the class definition.
      */
-    public function state(mixed $state): static
+    public function state(callable|array $state): static
     {
         return $this->newInstance([
             'states' => $this->states->concat([
-                is_callable($state) ? $state : function () use ($state) {
-                    return $state;
-                },
+                is_callable($state) ? $state : fn () => $state,
             ]),
         ]);
     }
 
+    /**
+     * Prepend a new state transformation to the class definition.
+     */
+    public function prependState(callable|array $state): static
+    {
+        return $this->newInstance([
+            'states' => $this->states->prepend(
+                is_callable($state) ? $state : fn () => $state,
+            ),
+        ]);
+    }
+
     /**
      * Set a single class attribute.
      */
@@ -242,6 +292,16 @@ public function afterMaking(Closure $callback): static
         ]);
     }
 
+    /**
+     * Remove the "after making" callbacks from the factory.
+     */
+    public function withoutAfterMaking(): static
+    {
+        return $this->newInstance([
+            'afterMaking' => new Collection,
+        ]);
+    }
+
     /**
      * Call the "after making" callbacks for the given class instances.
      */
@@ -299,8 +359,12 @@ protected function newFaker(): Generator
     /**
      * Handle dynamic state method calls.
      */
-    public function __call(string $method, array $parameters): static
+    public function __call(string $method, array $parameters): mixed
     {
+        if (static::hasMacro($method)) {
+            return $this->macroCall($method, $parameters);
+        }
+
         if (! $this->class) {
             throw new BadMethodCallException('Cannot call state methods on a factory without a using class.');
         }

tests/FactoryTest.php

@@ -34,6 +34,21 @@
     expect($instance->name)->toBe('foo');
 });
 
+it('can accept invokable attribute callbacks', function () {
+    $instance = FactoryStub::new(new class
+    {
+        public function __invoke(array $attributes): array
+        {
+            return [
+                'name' => 'Invokable',
+                'email' => $attributes['email'],
+            ];
+        }
+    })->make();
+
+    expect($instance->name)->toBe('Invokable');
+});
+
 it('can accept attribute closures', function () {
     $instance = FactoryStub::new()->make([
         'foo' => function (array $attributes) {
@@ -61,6 +76,30 @@
     expect($raws[0])->toHaveKeys(['name', 'email']);
 });
 
+it('can make a single instance after a count has been set', function () {
+    $instance = FactoryStub::new()->count(5)->makeOne();
+
+    expect($instance)->toBeInstanceOf(Data::class);
+});
+
+it('can make many instances from a number', function () {
+    $collection = FactoryStub::new()->makeMany(3);
+
+    expect($collection)->toBeInstanceOf(Collection::class);
+    expect($collection)->toHaveCount(3);
+});
+
+it('can make many instances from state records', function () {
+    $collection = FactoryStub::new()->makeMany([
+        ['name' => 'Taylor'],
+        ['name' => 'Nuno'],
+    ]);
+
+    expect($collection)->toHaveCount(2);
+    expect($collection[0]->name)->toBe('Taylor');
+    expect($collection[1]->name)->toBe('Nuno');
+});
+
 it('can accept sequence', function () {
     $collection = FactoryStub::new()
         ->count(3)
@@ -93,6 +132,22 @@
     expect($instance->id)->toBe(1);
 });
 
+it('can prepend state', function () {
+    $instance = FactoryStub::new()
+        ->state(['name' => 'Last'])
+        ->prependState(['name' => 'First'])
+        ->make();
+
+    expect($instance->name)->toBe('Last');
+});
+
+it('can lazily make instances', function () {
+    $lazy = FactoryStub::new()->lazy(['name' => 'Deferred']);
+
+    expect($lazy)->toBeInstanceOf(Closure::class);
+    expect($lazy()->name)->toBe('Deferred');
+});
+
 it('can create custom classes', function () {
     $instance = FactoryWithCustomClassStub::new()->make();
 
@@ -126,3 +181,25 @@
 
     expect($instance->name)->toBe('Custom');
 });
+
+it('can remove after making callbacks', function () {
+    $instance = FactoryWithConfigurationStub::new()
+        ->withoutAfterMaking()
+        ->make(['name' => 'Original']);
+
+    expect($instance->name)->toBe('Original');
+});
+
+it('can use macros', function () {
+    FactoryStub::macro('named', function (string $name) {
+        return $this->state(['name' => $name]);
+    });
+
+    try {
+        $instance = FactoryStub::new()->named('Macro')->make();
+
+        expect($instance->name)->toBe('Macro');
+    } finally {
+        FactoryStub::flushMacros();
+    }
+});