jefferson-lima / fixture-factory
Requires
- doctrine/annotations: ^1.10
- doctrine/orm: ^2.7
- fzaninotto/faker: ^1.9
- phpdocumentor/reflection-docblock: ^5.1
- symfony/validator: ^5.0
Requires (Dev)
- churchtools/changelogger: ^0.5.0
- friendsofphp/php-cs-fixer: ^2.16
- phpmd/phpmd: ^2.8
- phpstan/phpstan: ^0.12.25
- phpunit/phpunit: ^9
- roave/security-advisories: dev-master
- squizlabs/php_codesniffer: ^3.5
This package is auto-updated.
Last update: 2025-03-01 00:31:42 UTC
README
Generates fixture objects to be used in tests.
Installation
composer require jefferson-lima/fixture-factory
Usage
Fixture Factory uses the metadata of your class properties to generate values for them. The value generated for a
property is derived from its @var
tag. Thus, first you must annotate your properties with their types:
MyClass {
/** @var string */
public $foo;
public $bar;
}
The properties without a @var
tag, or with and invalid one, will be ignored.
Then you can use the FixtureFactory
to create a fixture for your class:
$myFixture = FixtureFactory::createFixture(MyClass::class);
Fixture Factory uses Faker to generate values.
Supported types
Currently, the supported types are string
, int
, bool
, float
. Objects are supported, as long
as a concrete class is provided. Abstract classes or interfaces are not supported as it's not possible
to determine the concrete implementation that should be used.
Nested objects will be generated recursively.
Overriding attributes
It's possible to override attributes by passing an array as a second argument to the createFixture
method:
$myFixture = FixtureFactory::createFixture(MyClass::class, ['foo' => 'bar']);
Circular references
Care must be taken with circular references, they must be avoided or overridden, otherwise an exception will be thrown. One example of circular reference is shown below:
class Foo {
/** @var Bar */
private $bar;
}
class Bar {
/** @var Foo */
private $foo;
}
A circular reference can be broken by overriding one attribute:
$myFixture = FixtureFactory::createFixture(MyClass::class, ['bar' => null]);
Doctrine annotations can also be used to resolve circular references, for example:
class Foo {
/**
* @var Bar
* @OneToOne(targetEntity="Bar", inversedBy="foo")
*/
private $bar;
}
class Bar {
/**
* @var Foo
* @OneToOne(targetEntity="Foo", mappedBy="bar")
*/
private $foo;
}
In this case, it's possible to identify that foo
points to bar
, and that bar
points back
at it.
Symfony constraints
It's also possible to use Symfony validation constraints to narrow down the values generated for your properties. These are the currently supported constraints listed by order of precedence:
Strings:
Some constraints can't be applied simultaneously. In this case, the constraint with higher precedence is applied. For example:
/**
* @Length(min=255)
* @Email
*/
private $email;
In this case, the @Email
constraint is applied, and the @Length
will be ignored.
Doctrine Associations
The following Doctrine associations are supported:
For many side of the associations an ArrayCollection with two elements is created.
License
This project is licensed under the MIT License - see the LICENSE.md file for details