Formations aurelearn

Génération de fixtures

Les fixtures sont de fausses données générées à des fins de tests. Vous pouvez générer autant de données que vous le souhaitez en installant les packages suivants :

shell

# Avec just
just composer require --dev orm-fixtures fakerphp/faker
# Sans just
docker compose run --rm composer require --dev orm-fixtures fakerphp/faker

L’installation vous crée un dossier /src/DataFixtures dans lequel vous spécifierez l’ensemble de vos fixtures. Elle vous met également à disposition le package FakerPHP ↗ qui apporte un ensemble de méthodes pour faciliter la création de fausses données.

Création d'une fixture abstraite

Certaines choses sont particulièrement pénibles à faire dans les fixtures, notamment la gestion des relations. Lorsque les fixtures sont découpées en plusieurs fichiers, il faut alors passer par deux méthodes fournies par la classe parente Fixture : getReference() et addReference().

Ce process est fastidieux et relativement complexe par rapport à ce que ça pourrait être, nous allons donc faire hériter toutes nos fixtures d’une classe abstraite qui s’occupera de gérer ces petites choses à un seul endroit dans notre codebase. Pour cela, créer une nouvelle classe AbstractFixture.php dans /src/DataFixtures :

AbstractFxiture.php

<?php
declare(strict_types=1);
namespace App\DataFixtures;
use App\Entity\AbstractEntity;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;
use Faker\Factory;
use Faker\Generator;
use Faker\Provider\fr_FR\PhoneNumber;
abstract class AbstractFixture extends Fixture
{
protected readonly Generator $faker;
protected const TOTAL_TO_GENERATE = 5;
protected const REFERENCE_KEY = '';
public function __construct() {
$this->faker = Factory::create('fr_FR');
$this->faker->addProvider(new PhoneNumber($this->faker));
}
/**
* @phpstan-param callable(Generator $faker, int $index): AbstractEntity $createEntity
*/
protected function generate(ObjectManager $manager, callable $createEntity): void
{
for ($index = 0; $index < $this::TOTAL_TO_GENERATE; $index++) {
$entityToPersist = $createEntity($this->faker, $index);
$manager->persist($entityToPersist);
$this->addRef($this::REFERENCE_KEY, $index, $entityToPersist);
}
$manager->flush();
}
protected function addRef(string $name, int $index, object $object): void
{
$this->addReference("{$name}_$index", $object);
}
/** @throws \Exception */
protected function getRef(string $name, int $index): object
{
$ref = "{$name}_$index";
if ($this->hasReference($ref)) {
return $this->getReference($ref);
}
throw new \Exception('No fixture reference exists with these name and index.');
}
}

Création de notre première fixture d'entité

Nous allons ensuite pouvoir créer notre première fixture avec la commande :

shell

# Avec just
sc make:fixtures
# Sans just
docker compose run --rm symfony console make:fixtures

Nommez vos fixtures de la manière suivante : nom de l’entité + “Fixtures” (ex: BookFixtures)

Et enfin la remplir comme dans l’exemple suivant :

BookFixtures.php

<?php
namespace App\DataFixtures;
use App\Entity\Book;
use Doctrine\Bundle\FixturesBundle\FixtureGroupInterface;
use Doctrine\Common\DataFixtures\DependentFixtureInterface;
use Doctrine\Persistence\ObjectManager;
use Faker\Generator;
class BookFixtures extends AbstractFixture implements FixtureGroupInterface, DependentFixtureInterface
{
protected const TOTAL_TO_GENERATE = 100;
protected const REFERENCE_KEY = 'book';
public function load(ObjectManager $manager): void
{
$this->generate(
manager: $manager,
createEntity: fn (Generator $faker) => (new Book())
->setTitle($faker->word)
->setSummary($faker->paragraph)
->setPrice($faker->randomFloat(nbMaxDecimals: 2))
->setReleaseDate(\DateTimeImmutable::createFromInterface($faker->dateTimeThisCentury))
);
}
public static function getGroups(): array
{
return ['dev', 'prod'];
}
public function getDependencies(): array
{
return [UserFixtures::class];
}
}

La méhode load

La méthode load est obligatoire puisque c’est elle qui est appelée au lancement de la fixture en question. À l’intérieur, nous appelons la méthode generate() de notre classe parente, qui elle se charge de boucler, persister puis sauvegarder les entités nouvellement créées.

La méthode generate() attend un deuxième paramètre qui est une fonction (un callback), dans laquelle nous créons notre entité puis la retournons. De cette manière, lorsque generate() boucle sur un nombre d’itérations, elle appellera à chaque fois le callback qui lui retournera une nouvelle entité.

La méhode getGroups

Le composant de fixtures met à disposition une interface FixtureGroupInterface à implémenter dans nos fixtures si on le souhaite. Cette implémentation requiert d’avoir une méthode nommée getGroups dans laquelle on retourne un tableau.

Grâce à cette méthode, vous pouvez désormais filtrer le lancement de vos fixtures à certains groupes, par exemple en faisant la commande suivante pour ne lancer que les fixtures de dév :

shell

# Avec just
just seed # --group=<env>
# Sans just
docker compose run --rm symfony console doctrine:fixtures:load # --group=<env>

La méhode getDependencies

Il arrive régulièrement que les fixtures se déroulent nécessairement dans un certain order pour que tout se passe bien. Par exemple si l’on a une relation User <-> Article, il faut obligatoirement que les faux User soient créés avant les faux Article pour pouvoir les lier.

Heureusement, le composant de fixtures nous permet de le faire simplement en implémentant l’interface DependentFixtureInterface et en remplissant la fonction getDependencies() par un tableau de toutes les fixtures dont elle dépend.

Dans l’exemple un peu plus haut, on voit donc que les fixtures pour l’entité Book doivent attendre que les fixtures de l’entité User soient chargées avant de pouvoir se déclencher.

© 2023 • Aurélien Devaux