At kununu we rely on data fixtures in our tests as well in our development and testing environments. A good definition of what fixtures are is the one from the documentation of DoctrineFixturesBundle in which the design and implementation of this package was heavily based on.

Fixtures are used to load a “fake” set of data into a database that can then be used for testing or to help give you some interesting data while you’re developing your application.

This package provides a simple way to manage and execute the loading of data fixtures for any storage mechanism. It's design and implementation was heavily based on the Doctrine data-fixtures package. If you are interested in why we created this package check out Why kununu/data-fixtures?.

Currently, this package supports the following types of fixtures:

• Doctrine DBAL Connection Fixtures which relies on Doctrine DBAL by using the Connection implementation
• Cache Pool Fixtures which relies on implementations of the PSR-6 standard
• Elasticsearch Fixtures which relies on the Elasticsearch-PHP client
• Symfony Http Client Fixtures which relies on the Symfony Http Client and Symfony Http Foundation.

Also check Directory Loader to check how to load fixtures from files in a directory.

If you are interested in knowing more about the concepts of the package, or you need to create a new fixture type check out How to create a new Fixture Type.

Before installing this package be aware:

• You own the fixtures you load
• This package should not be used in production mode!

composer require --dev kununu/data-fixtures

In order to enable the fixture types that you are interested, check out their documentation:

• Doctrine DBAL Connection Fixtures
• Cache Pool Fixtures
• Elasticsearch Fixtures
• Symfony Http Client Fixtures

By default, when loading fixtures the data storage is purged. If you want to change this behavior and instead append the fixtures you can pass false as second argument to any executor.

// By default, the data storage is purged
$executor->execute($loader->getFixtures());
// If you want you can `append` the fixtures instead of purging the database
$executor->execute($loader->getFixtures(), true);

In order to load fixtures the default Loader provides a couple of options:

1. loadFromDirectory(string $dir)
2. loadFromFile(string $fileName)
3. loadFromClassName(string $className)
4. addFixture(FixtureInterface $fixture)

$loader = new Kununu\DataFixtures\Loader\ConnectionFixturesLoader();
$loader->loadFromDirectory('/your/directory/');
$loader->loadFromFile('/your/file.php');
$loader->loadFromClassName(MyFixtureSql::class);
$loader->addFixture(new MyFixtureSql());

If you want your Fixture classes to be initialized you can implement the InitializableFixtureInterface

public function initializeFixture(...$args): void;

Then before loading the fixtures you need to register them in the Loader:

$loader = new Kununu\DataFixtures\Loader\ConnectionFixturesLoader();

$this->loader->registerInitializableFixture(
	YourFixtureClass::class,
	// 1st argument
	1, 
	// 2nd argument
	'This is an argument that will be passed to initializeFixture of YourFixtureClass',
	// 3rd argument
	[
		'field'    => 'field-name',
		'value' => 10,
	],
	// 4th argument
	$anInstanceOfOneOfYourOtherClasses
	// Pass as many arguments as you like...
);

$loader->addFixture(new YourFixtureClass());

If you are interested in contributing read our contributing guidelines.

If not yet, first install composer dependencies:

composer install

Run the tests by doing:

vendor/bin/phpunit

To run tests without coverage report:

composer install
composer test

To run tests with coverage report:

composer install
composer test-coverage