Doctrine Fixture Loader Bundle Laravel Package

Getting Started

Minimal Steps

1. Installation Run composer require delbio/doctrine-fixture-loader-bundle in your Laravel project. (Note: This bundle is Symfony-based, so Laravel integration requires manual setup.)

2. Enable the Bundle Add the bundle to config/app.php under extra.bundles (Symfony-style) or manually register it in a service provider. (Laravel 5.5+ users: Use config/app.php or a custom Kernel class.)

3. First Use Case Create a fixture class extending Delbio\Bundle\DoctrineFixtureLoaderBundle\AbstractFixtureLoader:

   namespace App\Fixtures;
   
   use Delbio\Bundle\DoctrineFixtureLoaderBundle\AbstractFixtureLoader;
   use Doctrine\Common\DataFixtures\FixtureInterface;
   
   class UserFixture extends AbstractFixtureLoader implements FixtureInterface
   {
       public function load(ObjectManager $manager)
       {
           $user = new User();
           $user->setName('Test User');
           $manager->persist($user);
           $manager->flush();
       }
   }
   

4. Load Fixtures Use the doctrine:fixtures:load command:

   php bin/console doctrine:fixtures:load --fixtures="App\Fixtures\UserFixture"
   

   (Laravel: Create an Artisan command or use Artisan::call() in a test.)

Implementation Patterns

Workflows

1. Test Data Setup Use fixtures in phpunit.xml or php artisan test:

   <env name="DB_DUMPER" value="true"/>
   <env name="DB_FIXTURES" value="App\Fixtures\UserFixture,App\Fixtures\PostFixture"/>
   

2. Environment-Specific Fixtures Load different fixtures per environment (e.g., dev, test):

   // config/fixtures.php
   'fixtures' => [
       'dev' => ['App\Fixtures\DevUserFixture'],
       'test' => ['App\Fixtures\TestUserFixture'],
   ],
   

   Load via:

   php bin/console doctrine:fixtures:load --env=test
   

3. Dependency Injection Inject DoctrineFixtureLoaderBundle services into controllers/services:

   use Delbio\Bundle\DoctrineFixtureLoaderBundle\Loader\FixtureLoader;
   
   class UserController extends Controller
   {
       public function __construct(FixtureLoader $loader)
       {
           $this->loader = $loader;
       }
   
       public function seed()
       {
           $this->loader->loadFixtures(['App\Fixtures\UserFixture']);
       }
   }
   

4. Laravel Integration

   • Service Provider:

     namespace App\Providers;
     
     use Illuminate\Support\ServiceProvider;
     use Delbio\Bundle\DoctrineFixtureLoaderBundle\DoctrineFixtureLoaderBundle;
     
     class FixtureServiceProvider extends ServiceProvider
     {
         public function register()
         {
             $this->app->bind('fixture.loader', function ($app) {
                 return new DoctrineFixtureLoaderBundle();
             });
         }
     }
     

   • Artisan Command:

     namespace App\Console\Commands;
     
     use Illuminate\Console\Command;
     use Delbio\Bundle\DoctrineFixtureLoaderBundle\Loader\FixtureLoader;
     
     class LoadFixtures extends Command
     {
         protected $signature = 'fixtures:load {fixtures*}';
         protected $description = 'Load Doctrine fixtures';
     
         public function handle(FixtureLoader $loader)
         {
             $loader->loadFixtures($this->argument('fixtures'));
         }
     }
     

5. Custom Fixture Loading Extend AbstractFixtureLoader for reusable logic:

   abstract class BaseFixture extends AbstractFixtureLoader
   {
       protected function createUser(string $name): User
       {
           $user = new User();
           $user->setName($name);
           return $user;
       }
   }
   

Gotchas and Tips

Pitfalls

1. Symfony Dependency

   • The bundle assumes Symfony’s Kernel and Console components. Laravel users must mock or alias these.
   • Fix: Use a facade or wrapper class to bridge Symfony’s ObjectManager to Laravel’s EntityManager.

2. Fixture Ordering

   • Fixtures load alphabetically by default. Use setOrder() to control execution:

     class PostFixture extends AbstractFixtureLoader
     {
         public function setOrder(): int
         {
             return 2; // Runs after UserFixture (order=1)
         }
     }
     

3. Database Transactions

   • Fixtures run in a single transaction by default. Disable with --append:

     php bin/console doctrine:fixtures:load --append
     

4. Laravel Eloquent vs. Doctrine ORM

   • The bundle uses Doctrine ORM. For Eloquent, convert fixtures to use Laravel’s Model:

     use App\Models\User;
     
     $user = new User();
     $user->name = 'Test';
     $user->save(); // Instead of $manager->persist()
     

5. Caching Issues

   • Clear cache after adding new fixtures:

     php artisan cache:clear
     php bin/console cache:clear
     

Debugging

• Fixture Not Loading? Check:

  • Bundle is enabled in AppKernel/config/app.php.
  • Fixture class implements FixtureInterface.
  • Doctrine’s EntityManager is properly injected.

• Duplicate Entries Use ORM\Query\QueryException to handle duplicates:

  try {
      $manager->persist($user);
      $manager->flush();
  } catch (\Doctrine\ORM\ORMException $e) {
      $manager->clear();
  }
  

Tips

1. Reusable Fixture Data Store fixture data in YAML/JSON and load dynamically:

   $users = \Symfony\Component\Yaml\Yaml::parse(file_get_contents('fixtures/users.yml'));
   foreach ($users as $userData) {
       $user = new User();
       $user->setName($userData['name']);
       $manager->persist($user);
   }
   

2. Fixture Validation Add assertions in fixtures to validate data:

   public function load(ObjectManager $manager)
   {
       $user = $manager->find(User::class, 1);
       $this->assertNotNull($user, 'User fixture not loaded');
   }
   

3. Environment Variables Use .env for dynamic fixture data:

   $email = env('FIXTURE_USER_EMAIL', 'default@example.com');
   

4. Performance Disable events during bulk loads:

   $manager->getConnection()->getConfiguration()->setSQLLogger(null);
   $manager->getEventManager()->clear();
   

5. Laravel Testing Load fixtures in setUp():

   public function setUp(): void
   {
       parent::setUp();
       Artisan::call('fixtures:load', ['fixtures' => 'App\Fixtures\UserFixture']);
   }