Getting Started

Minimal Steps

Installation:
```
composer require directorytree/dummy
```
- No Laravel dependency required (since v1.1.0), but orchestra/testbench is needed for Laravel-specific testing.

Basic Instantiation:

use DirectoryTree\Dummy\Dummy;

$dummy = new Dummy();

First Use Case: Generate a Single Fake Model

$user = $dummy->make('App\Models\User', [
    'name' => 'Test User',
    'email' => 'test@example.com'
]);

Replace App\Models\User with your Eloquent model or class name.

First Use Case: Generate Multiple Fake Models

$users = $dummy->times(5)->make('App\Models\User');

First Use Case: Use with Laravel’s HasFactory (if applicable)

use DirectoryTree\Dummy\Concerns\HasFactory;

class User extends Model
{
    use HasFactory;
}

// In test:
$user = User::factory()->create();

Where to Look First

Package Docs: GitHub Repository (limited but clear).
Release Notes: Focus on v1.3.0+ for HasFactory and Arr helper improvements.
Examples: Check the tests/ directory in the repo for usage patterns.

Implementation Patterns

Core Workflows

Basic Data Generation

$dummy = new Dummy();
$post = $dummy->make('App\Models\Post', [
    'title' => 'Dummy Post',
    'content' => 'This is a test post.'
]);

Bulk Data Generation

$posts = $dummy->times(10)->make('App\Models\Post');

Dynamic Attributes with filled()

$user = $dummy->make('App\Models\User');
$user->filled('email', fn() => 'dynamic@example.com');

Integration with Laravel’s HasFactory

// In your model:
use DirectoryTree\Dummy\Concerns\HasFactory;

class User extends Model
{
    use HasFactory;
}

// In test:
$user = User::factory()->create();

Stateful Factories (v1.3.0+)

User::factory()
    ->state(['role' => 'admin'])
    ->create();

Laravel-Specific Patterns

Using with Eloquent Relationships

$user = User::factory()->create();
$user->posts()->saveMany(
    Post::factory()->count(3)->create()
);

Customizing Factories via HasFactory

// In model:
public function defineDummy()
{
    return [
        'name' => $this->faker->name,
        'email' => $this->faker->unique()->safeEmail,
    ];
}

PestPHP Integration

use DirectoryTree\Dummy\Dummy;

it('creates a user', function () {
    $dummy = new Dummy();
    $user = $dummy->make('App\Models\User');
    expect($user->email)->toBeString();
});

Non-Laravel Patterns

Generating Plain PHP Objects

$dummy = new Dummy();
$data = $dummy->make(stdClass::class, [
    'id' => 1,
    'name' => 'Test Object'
]);

Using with Collections

$collection = collect($dummy->times(5)->make(stdClass::class));

Custom Faker Providers

$dummy->faker()->addProvider(new CustomFakerProvider());

Gotchas and Tips

Pitfalls

Non-Stringable Objects in filled() (v2.0.1 Fix)
- Issue: filled() throws an exception if the attribute holds a non-Stringable object (e.g., DateTime, Carbon).
- Fix: Ensure attributes passed to filled() are compatible or cast them:
```
$user->filled('created_at', fn() => now()->format('Y-m-d'));
```
Late Static Binding in HasFactory (v1.6.1 Fix)
- Issue: Static closures in HasFactory may fail if not bound correctly.
- Fix: Use static:: or ensure proper closure binding:
```
public function defineDummy()
{
    return [
        'name' => static::faker()->name,
    ];
}
```
Laravel-Specific Assumptions
- Issue: Methods like Arr::get() assume Laravel’s Arr helper (v1.3.1+).
- Fix: For non-Laravel projects, replace with array_key_first() or similar:
```
// Non-Laravel alternative:
$value = array_key_first($array) ?: null;
```
Dynamic States Overhead
- Issue: Complex stateful factories can slow down tests if not optimized.
- Fix: Cache factory definitions or use simpler states where possible.
No Built-in Database Seeding
- Issue: The package generates objects in memory; you must manually persist them (e.g., create() for Eloquent).
- Fix: Chain with Eloquent methods:
```
$user = User::factory()->create(); // Persists to DB
```

Debugging Tips

Inspect Generated Data

$dummy = new Dummy();
$data = $dummy->make('App\Models\User');
dd($data->toArray()); // Debug output

Check Faker Providers
- Ensure custom providers are registered:
```
$dummy->faker()->addProvider(new CustomProvider());
```

Validate HasFactory Definitions

If factories behave unexpectedly, verify the defineDummy() method:

public function defineDummy()
{
    return [
        'name' => $this->faker->name,
        // Ensure all required fields are defined
    ];
}

Extension Points

Custom Faker Providers

use Faker\Provider\Base as FakerProvider;

class CustomProvider extends FakerProvider
{
    public function customField()
    {
        return 'custom_value';
    }
}

$dummy->faker()->addProvider(new CustomProvider());

Override Default Attributes

$dummy->make('App\Models\User', [
    'name' => 'Override Name',
    'email' => 'override@example.com'
]);

Dynamic Factory States

User::factory()
    ->state(['role' => 'admin'])
    ->state(fn(array $attributes) => [
        'is_active' => $attributes['role'] === 'admin' ? true : false,
    ])
    ->create();

Integration with Laravel’s Fake

use Illuminate\Foundation\Testing\WithFaker;

class UserFactoryTest extends TestCase
{
    use WithFaker;

    public function testFactory()
    {
        $user = User::factory()->create();
        $this->assertEquals('test@example.com', $user->email);
    }
}

Configuration Quirks

Laravel 13+ Compatibility
- The package explicitly supports Laravel 13 (v1.4.0+), but some features may require adjustments for newer Laravel versions.

Generic Types (v1.5.1)

Useful for type-hinted properties:

$dummy->make(stdClass::class, [
    'id' => 1,
    'name' => 'Test',
]);

Factory Method Parity (v1.5.0)
- Mimics Laravel’s factory() methods for consistency:
```
$user = User::factory()->create(); // Works if using HasFactory
```

Performance Tips

Avoid Overusing Dynamic States
- Complex state logic can slow down bulk operations. Simplify where possible.
Cache Factory Definitions
- For frequently used factories, define them in a trait or base class to avoid re-parsing.

Use times() Efficiently

Generate data in batches to reduce memory usage:

$dummy->times(100)->make('App\Models\User'); // Better than looping manually

Dummy Laravel Package