Symfony test data and Doctrine fixtures, FK-consistent from your schema

Install the Symfony bundle for Doctrine fixtures

Install the package and register the bundle, then SeedBase plugs into the fixtures workflow you already run. Pull it in with Composer:

composer require seedbase/seedbase

Register the bundle in config/bundles.php:

<?php
// config/bundles.php
return [
    // ...
    Seedbase\Symfony\SeedbaseBundle::class => ['all' => true],
];

Then configure your token, project and seed in config/packages/seedbase.yaml. The token resolves from the environment, so no secret lives in the repo:

# config/packages/seedbase.yaml
seedbase:
    token:   '%env(SEEDBASE_TOKEN)%'
    api_url: 'https://seedbase.dev/api/v1'
    project: '%env(SEEDBASE_PROJECT)%'
    seed:    '%env(int:SEEDBASE_SEED)%'

Grab a free API key under Settings, API keys (it looks like dr_sk_...) and put it in SEEDBASE_TOKEN. Create a project by importing your schema (a SQL dump, or a live database URL) at seedbase.dev and use its id as SEEDBASE_PROJECT.

Fill the database with doctrine:fixtures:load

As a DoctrineFixturesBundle alternative for the bulk of your data, you stop writing a fixture class per entity. The bundle ships a single SeedbaseFixtures class that extends the DoctrineFixturesBundle Fixture, so you load it exactly the way you already load fixtures:

php bin/console doctrine:fixtures:load

The autowired SeedbaseFixtures generates and loads foreign-key-consistent data over your Doctrine connection, using the project and seed from your config. Your schema must already exist, your migrations own it. SeedBase reads that schema, generates realistic rows that satisfy every relationship, and inserts them parent-before-child so the load succeeds with constraints on.

Inject the SeedbaseClient in a service or command

Once the bundle is registered, SeedbaseClient is autowirable. Type-hint it in any service, controller or console command and Symfony injects a configured instance, so you can drive generation from your own code: generate a dataset, then download it as SQL.

<?php
// src/Command/SeedCommand.php
namespace App\Command;

use Seedbase\SeedbaseClient;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(name: 'app:seed')]
final class SeedCommand extends Command
{
    public function __construct(private SeedbaseClient $client)
    {
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $gen = $this->client->generate('my-project', ['seed' => 42, 'wait' => true]);
        $sql = $this->client->download($gen['id'], 'sql');

        file_put_contents('var/seed.sql', $sql);

        return Command::SUCCESS;
    }
}

generate() creates a generation and, with wait => true, blocks until it is ready, so $gen['id'] is the finished generation. download($id, 'sql') returns the INSERT statements as a string, ready to load with doctrine:database:import or pipe into psql in CI. Pass a fixed seed and the run is reproducible.

Realistic, foreign-key-consistent data

The value is the engine, not the thin Symfony adapter. SeedBase resolves foreign keys across tables, so an order that points at a customer always finds a customer that exists, and the rows load with constraints on. It uses realistic distributions and coherent free text, so a description reads like a description and an email reads like an email, instead of "Premium Widget 1" or lorem ipsum your assertions can never trust.

• Foreign keys resolved across tables, with rows inserted parent-before-child.
• Realistic value distributions and coherent free text, not placeholder filler.
• One generation feeds the fixture, an autowired client call or a plain SQL download.

This complements Faker and Doctrine fixtures rather than replacing them. Faker invents one field at a time and a fixture wires the relations by hand; SeedBase invents the whole dataset schema-aware, so the foreign keys line up across hundreds of tables without you writing the wiring. Keep the bespoke fixtures that encode a specific scenario, let SeedBase fill the bulk.

Deterministic and reproducible

Generation is seeded. The same seed produces the same data, every run. That keeps CI reproducible: the same fixture yields the same rows on every machine, so a green build stays green for the right reason. When a test fails, reuse the seed and you reproduce the exact dataset that broke it, instead of chasing a fixture that has since been hand-edited.

Free tier

Generation and SQL or JSON download are free to use, no credit card. You do not need push-to-database or any paid feature to seed your Symfony tests, because the data loads through your own Doctrine connection. Generate once, run doctrine:fixtures:load, and the bundle wires it into the database. Paid plans start at €19/month and add Parquet export, direct database push and higher row limits when you want them.

Try it

There is a runnable example you can clone and run, so you watch a real FK-consistent dataset get loaded through a Doctrine connection. Then point it at your own schema.

php examples/doctrine_seed_demo.php

• Paste a schema and look at the rows in the login-free sandbox, no account needed.
• On Laravel instead of Symfony? See Laravel test data, same engine, same FK-consistency.
• Prefer raw INSERT statements over a fixture? See SQL test data.
• Coming from Faker? SeedBase vs Faker shows where each one fits.
• Read the docs for the Symfony bundle and the SeedbaseClient service.