Laravel Dummy Models Laravel Package

Getting Started

Minimal Setup

1. Installation:

   composer require cetria/laravel-dummy-models
   

   Publish the config file (if needed):

   php artisan vendor:publish --provider="Cetria\LaravelDummyModels\DummyModelsServiceProvider"
   

2. Basic Usage: Generate a dummy model for an existing table (e.g., users):

   php artisan dummy:model User
   

   This creates a UserDummy class in app/Dummies/ with factory methods for common dummy data.

3. First Use Case:

   use App\Dummies\UserDummy;
   
   $dummyUser = UserDummy::create();
   // Returns a User model with realistic dummy data (e.g., name, email, etc.)
   

Implementation Patterns

Workflows

1. Generating Dummies:

   • Single Model:

     php artisan dummy:model Post
     

   • Batch Generation (via config or custom command):

     // In a custom command:
     $this->call('dummy:model', ['model' => 'Product']);
     

2. Customizing Dummies:

   • Override the generated UserDummy in app/Dummies/UserDummy.php:

     public static function create()
     {
         return User::factory()->create([
             'name' => 'Custom Name',
             'email' => '[email protected]',
         ]);
     }
     

3. Integration with Tests:

   use App\Dummies\UserDummy;
   
   public function test_something()
   {
       $user = UserDummy::create();
       $this->assertDatabaseHas('users', ['email' => $user->email]);
   }
   

4. Dynamic Dummy Data: Use the with() method to inject specific attributes:

   $dummyUser = UserDummy::create()->with(['role' => 'admin']);
   

Integration Tips

• Seeding: Use dummies in DatabaseSeeder to populate test databases:

  UserDummy::create(['name' => 'Test User']);
  

• API Testing: Generate dummies for authentication or payload testing:

  $token = auth()->login(UserDummy::create());
  

• Custom Factories: Extend the package’s factory logic by overriding methods like random() or faker() in your dummy class.

Gotchas and Tips

Pitfalls

1. Model Existence: The package assumes the target model (e.g., User) exists. Generate dummies after defining the model.

2. Faker Dependencies: Ensure fakerphp/faker is installed (it’s a dependency, but verify in composer.json).

3. Overwriting Dummies: Regenerating a dummy (e.g., php artisan dummy:model User) will overwrite the existing file. Back up customizations.

4. Mass Assignment: Dummies may include sensitive fields (e.g., password). Use ->except('password') or whitelist safe fields:

   $dummy = UserDummy::create()->except(['password']);
   

Debugging

• Empty Dummies: Check if the model’s fillable fields are correctly defined. The package uses fillable to determine attributes.

• Faker Issues: If Faker\Generator throws errors, ensure your config/app.php includes the Faker provider:

  'providers' => [
      Faker\Faker\FakerServiceProvider::class,
  ],
  

Extension Points

1. Custom Attributes: Add a customAttributes() method to your dummy class:

   protected static function customAttributes()
   {
       return ['is_active' => true];
   }
   

2. Relationships: Chain dummies to create nested data:

   $user = UserDummy::create();
   $user->posts()->save(PostDummy::create());
   

3. Conditional Logic: Use when() to conditionally set attributes:

   $dummy = UserDummy::create()->when(fn() => true, fn($user) => $user->update(['verified' => true]));
   

4. Config Overrides: Modify config/dummy-models.php to change default behavior (e.g., dummy directory path or factory class).

Pro Tips

• Test Data Factories: Combine with Laravel’s built-in factories for hybrid approaches:

  public static function create()
  {
      return User::factory()->create([
          'email_verified_at' => now(),
      ]);
  }
  

• Performance: For bulk operations, use createMany() (if supported by the dummy class):

  UserDummy::createMany(5); // Creates 5 dummy users
  

• Localization: Use Faker’s localization to generate region-specific data:

  $dummy = UserDummy::create()->withFakerLocale('fr_FR');