TestEntityGenerator::generateDtoRelatedToEntity() - Code Metrics - Inspection of "Merge pull request #154 from edmondscommerce/6-dev" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0d13eb...0e53de )

by joseph

created 2019-01-03 10:56 UTC

TestEntityGenerator::generateDtoRelatedToEntity() A

↳ Parent: TestEntityGenerator

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	1.0156

Importance

Changes

Metric	Value
cc	1
eloc	5
nc	1
nop	1
dl	0
loc	9
ccs	6
cts	8
cp	0.75
crap	1.0156
rs	10
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityGenerator;

use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\DoctrineStaticMeta;
use EdmondsCommerce\DoctrineStaticMeta\Entity\DataTransferObjects\DtoFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactoryInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\DataTransferObjectInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;

/**
 * Class TestEntityGenerator
 *
 * This class handles utilising Faker to build up an Entity and then also possible build associated entities and handle
 * the association
 *
 * Unique columns are guaranteed to have a totally unique value in this particular process, but not between processes
 *
 * This Class provides you a few ways to generate test Entities, either in bulk or one at a time
 *ExcessiveClassComplexity
 *
 * @package EdmondsCommerce\DoctrineStaticMeta\Entity\Testing
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class TestEntityGenerator
{
    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    /**
     * @var DoctrineStaticMeta
     */
    protected $testedEntityDsm;

    /**
     * @var EntityFactoryInterface
     */
    protected $entityFactory;
    /**
     * @var DtoFactory
     */
    private $dtoFactory;
    /**
     * @var TestEntityGeneratorFactory
     */
    private $testEntityGeneratorFactory;
    /**
     * @var FakerDataFiller
     */
    private $fakerDataFiller;


    /**
     * TestEntityGenerator constructor.
     *
     * @param DoctrineStaticMeta          $testedEntityDsm
     * @param EntityFactoryInterface|null $entityFactory
     * @param DtoFactory                  $dtoFactory
     * @param TestEntityGeneratorFactory  $testEntityGeneratorFactory
     * @param FakerDataFiller             $fakerDataFiller
     * @param EntityManagerInterface      $entityManager
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function __construct(
        DoctrineStaticMeta $testedEntityDsm,
        EntityFactoryInterface $entityFactory,
        DtoFactory $dtoFactory,
        TestEntityGeneratorFactory $testEntityGeneratorFactory,
        FakerDataFiller $fakerDataFiller,
        EntityManagerInterface $entityManager
    ) {
        $this->testedEntityDsm            = $testedEntityDsm;
        $this->entityFactory              = $entityFactory;
        $this->dtoFactory                 = $dtoFactory;
        $this->testEntityGeneratorFactory = $testEntityGeneratorFactory;
        $this->fakerDataFiller            = $fakerDataFiller;
        $this->entityManager              = $entityManager;
    }


    public function assertSameEntityManagerInstance(EntityManagerInterface $entityManager): void
    {
        if ($entityManager === $this->entityManager) {
            return;
        }
        throw new \RuntimeException('EntityManager instance is not the same as the one loaded in this factory');
    }

    /**
     * Use the factory to generate a new Entity, possibly with values set as well
     *
     * @param array $values
     *
     * @return EntityInterface
     */
    public function create(array $values = []): EntityInterface
    {
        $dto = $this->dtoFactory->createEmptyDtoFromEntityFqn($this->testedEntityDsm->getReflectionClass()->getName());
        if ([] !== $values) {
            foreach ($values as $property => $value) {
                $setter = 'set' . $property;
                $dto->$setter($value);
            }
        }

        return $this->entityFactory->create(
            $this->testedEntityDsm->getReflectionClass()->getName(),
            $dto
        );
    }

    /**
     * Generate an Entity. Optionally provide an offset from the first entity
     *
     * @return EntityInterface
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ErrorException
     * @throws \ReflectionException
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function generateEntity(): EntityInterface
    {
        return $this->createEntityWithData();
    }

    private function createEntityWithData(): EntityInterface
    {
        $dto = $this->generateDto();

        return $this->entityFactory->create($this->testedEntityDsm->getReflectionClass()->getName(), $dto);
    }

    public function generateDto(): DataTransferObjectInterface
    {
        $dto = $this->dtoFactory->createEmptyDtoFromEntityFqn(
            $this->testedEntityDsm->getReflectionClass()->getName()
        );
        $this->fakerUpdateDto($dto);

        return $dto;
    }

    public function fakerUpdateDto(DataTransferObjectInterface $dto): void
    {
        $this->fakerDataFiller->updateDtoWithFakeData($dto);
    }

    /**
     * @param EntityInterface $generated
     *
     * @throws \ErrorException
     * @SuppressWarnings(PHPMD.ElseExpression)
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     */
    public function addAssociationEntities(
        EntityInterface $generated
    ): void {
        $testedEntityReflection = $this->testedEntityDsm->getReflectionClass();
        $class                  = $testedEntityReflection->getName();
        $meta                   = $this->testedEntityDsm->getMetaData();
        $mappings               = $meta->getAssociationMappings();
        if (empty($mappings)) {
            return;
        }
        $namespaceHelper = new NamespaceHelper();
        $methods         = array_map('strtolower', get_class_methods($generated));
        foreach ($mappings as $mapping) {
            $mappingEntityFqn                     = $mapping['targetEntity'];
            $errorMessage                         = "Error adding association entity $mappingEntityFqn to $class: %s";
            $mappingEntityPluralInterface         =
                $namespaceHelper->getHasPluralInterfaceFqnForEntity($mappingEntityFqn);
            $mappingEntityPluralInterfaceRequired =
                str_replace('\\Has', '\\HasRequired', $mappingEntityPluralInterface);
            if ((\interface_exists($mappingEntityPluralInterface) &&
                 $testedEntityReflection->implementsInterface($mappingEntityPluralInterface))
                ||
                (\interface_exists($mappingEntityPluralInterfaceRequired)
                 && $testedEntityReflection->implementsInterface($mappingEntityPluralInterfaceRequired))
            ) {
                $this->assertSame(
                    $mappingEntityFqn::getDoctrineStaticMeta()->getPlural(),
                    $mapping['fieldName'],
                    sprintf($errorMessage, ' mapping should be plural')
                );
                $getter = 'get' . $mappingEntityFqn::getDoctrineStaticMeta()->getPlural();
                $method = 'add' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
            } else {
                $this->assertSame(
                    $mappingEntityFqn::getDoctrineStaticMeta()->getSingular(),
                    $mapping['fieldName'],
                    sprintf($errorMessage, ' mapping should be singular')
                );
                $getter = 'get' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
                $method = 'set' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
            }
            $this->assertInArray(
                strtolower($method),
                $methods,
                sprintf($errorMessage, $method . ' method is not defined')
            );
            try {
                $currentlySet = $generated->$getter();
            } catch (\TypeError $e) {
                $currentlySet = null;
            }
            $this->addAssociation($generated, $method, $mappingEntityFqn, $currentlySet);
        }
    }

    /**
     * Stub of PHPUnit Assertion method
     *
     * @param mixed  $expected
     * @param mixed  $actual
     * @param string $error
     *
     * @throws \ErrorException
     */
    protected function assertSame($expected, $actual, string $error): void
    {
        if ($expected !== $actual) {
            throw new \ErrorException($error);
        }
    }

    /**
     * Stub of PHPUnit Assertion method
     *
     * @param mixed  $needle
     * @param array  $haystack
     * @param string $error
     *
     * @throws \ErrorException
     */
    protected function assertInArray($needle, array $haystack, string $error): void
    {
        if (false === \in_array($needle, $haystack, true)) {
            throw new \ErrorException($error);
        }
    }

    private function addAssociation(
        EntityInterface $generated,
        string $setOrAddMethod,
        string $mappingEntityFqn,
        $currentlySet
    ): void {
        $testEntityGenerator = $this->testEntityGeneratorFactory
            ->createForEntityFqn($mappingEntityFqn);
        switch (true) {
            case $currentlySet === null:
            case $currentlySet === []:
            case $currentlySet instanceof Collection:
                $mappingEntity = $testEntityGenerator->createEntityRelatedToEntity($generated);
                break;
            default:
                return;
        }
        $generated->$setOrAddMethod($mappingEntity);
        $this->entityManager->persist($mappingEntity);
    }

    /**
     * @param EntityInterface $entity
     *
     * @return mixed
     * @SuppressWarnings(PHPMD.UnusedPrivateMethod - it is being used)
     */
    private function createEntityRelatedToEntity(EntityInterface $entity)
    {
        $dto = $this->generateDtoRelatedToEntity($entity);

        return $this->entityFactory->create(
            $this->testedEntityDsm->getReflectionClass()->getName(),
            $dto
        );
    }

    public function generateDtoRelatedToEntity(EntityInterface $entity): DataTransferObjectInterface
    {
        $dto = $this->dtoFactory->createDtoRelatedToEntityInstance(
            $entity,
            $this->testedEntityDsm->getReflectionClass()->getName()
        );
        $this->fakerDataFiller->updateDtoWithFakeData($dto);

        return $dto;
    }

    /**
     * Generate Entities.
     *
     * Optionally discard the first generated entities up to the value of offset
     *
     * @param int $num
     *
     * @return array|EntityInterface[]
     */
    public function generateEntities(
        int $num
    ): array {
        $entities  = [];
        $generator = $this->getGenerator($num);
        foreach ($generator as $entity) {
            $id = (string)$entity->getId();
            if (array_key_exists($id, $entities)) {
                throw new \RuntimeException('Entity with ID ' . $id . ' is already generated');
            }
            $entities[$id] = $entity;
        }

        return $entities;
    }

    public function getGenerator(int $numToGenerate = 100): \Generator
    {
        $entityFqn = $this->testedEntityDsm->getReflectionClass()->getName();
        $generated = 0;
        while ($generated < $numToGenerate) {
            $dto    = $this->generateDto();
            $entity = $this->entityFactory->setEntityManager($this->entityManager)->create($entityFqn, $dto);
            yield $entity;
            $generated++;
        }
    }

    /**
     * @return EntityFactoryInterface
     */
    public function getEntityFactory(): EntityFactoryInterface
    {
        return $this->entityFactory;
    }

    /**
     * @return DtoFactory
     */
    public function getDtoFactory(): DtoFactory
    {
        return $this->dtoFactory;
    }

    /**
     * @return FakerDataFiller
     */
    public function getFakerDataFiller(): FakerDataFiller
    {
        return $this->fakerDataFiller;
    }

    /**
     * @return EntityManagerInterface
     */
    public function getEntityManager(): EntityManagerInterface
    {
        return $this->entityManager;
    }

    /**
     * @return TestEntityGeneratorFactory
     */
    public function getTestEntityGeneratorFactory(): TestEntityGeneratorFactory
    {
        return $this->testEntityGeneratorFactory;
    }
}


1		<?php declare(strict_types=1);
2
3		namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityGenerator;
4
5		use Doctrine\Common\Collections\Collection;
6		use Doctrine\ORM\EntityManagerInterface;
7		use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
8		use EdmondsCommerce\DoctrineStaticMeta\DoctrineStaticMeta;
9		use EdmondsCommerce\DoctrineStaticMeta\Entity\DataTransferObjects\DtoFactory;
10		use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactoryInterface;
11		use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\DataTransferObjectInterface;
12		use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
13
14		/**
15		* Class TestEntityGenerator
16		*
17		* This class handles utilising Faker to build up an Entity and then also possible build associated entities and handle
18		* the association
19		*
20		* Unique columns are guaranteed to have a totally unique value in this particular process, but not between processes
21		*
22		* This Class provides you a few ways to generate test Entities, either in bulk or one at a time
23		*ExcessiveClassComplexity
24		*
25		* @package EdmondsCommerce\DoctrineStaticMeta\Entity\Testing
26		* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
27		* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
28		*/
29		class TestEntityGenerator
30		{
31		/**
32		* @var EntityManagerInterface
33		*/
34		protected $entityManager;
35
36		/**
37		* @var DoctrineStaticMeta
38		*/
39		protected $testedEntityDsm;
40
41		/**
42		* @var EntityFactoryInterface
43		*/
44		protected $entityFactory;
45		/**
46		* @var DtoFactory
47		*/
48		private $dtoFactory;
49		/**
50		* @var TestEntityGeneratorFactory
51		*/
52		private $testEntityGeneratorFactory;
53		/**
54		* @var FakerDataFiller
55		*/
56		private $fakerDataFiller;
57
58
59		/**
60		* TestEntityGenerator constructor.
61		*
62		* @param DoctrineStaticMeta $testedEntityDsm
63		* @param EntityFactoryInterface\|null $entityFactory
64		* @param DtoFactory $dtoFactory
65		* @param TestEntityGeneratorFactory $testEntityGeneratorFactory
66		* @param FakerDataFiller $fakerDataFiller
67		* @param EntityManagerInterface $entityManager
68		* @SuppressWarnings(PHPMD.StaticAccess)
69		*/
70	7	public function __construct(
71		DoctrineStaticMeta $testedEntityDsm,
72		EntityFactoryInterface $entityFactory,
73		DtoFactory $dtoFactory,
74		TestEntityGeneratorFactory $testEntityGeneratorFactory,
75		FakerDataFiller $fakerDataFiller,
76		EntityManagerInterface $entityManager
77		) {
78	7	$this->testedEntityDsm = $testedEntityDsm;
79	7	$this->entityFactory = $entityFactory;
80	7	$this->dtoFactory = $dtoFactory;
81	7	$this->testEntityGeneratorFactory = $testEntityGeneratorFactory;
82	7	$this->fakerDataFiller = $fakerDataFiller;
83	7	$this->entityManager = $entityManager;
84	7	}
85
86
87		public function assertSameEntityManagerInstance(EntityManagerInterface $entityManager): void
88		{
89		if ($entityManager === $this->entityManager) {
90		return;
91		}
92		throw new \RuntimeException('EntityManager instance is not the same as the one loaded in this factory');
93		}
94
95		/**
96		* Use the factory to generate a new Entity, possibly with values set as well
97		*
98		* @param array $values
99		*
100		* @return EntityInterface
101		*/
102	2	public function create(array $values = []): EntityInterface
103		{
104	2	$dto = $this->dtoFactory->createEmptyDtoFromEntityFqn($this->testedEntityDsm->getReflectionClass()->getName());
105	2	if ([] !== $values) {
106	1	foreach ($values as $property => $value) {
107	1	$setter = 'set' . $property;
108	1	$dto->$setter($value);
109		}
110		}
111
112	2	return $this->entityFactory->create(
113	2	$this->testedEntityDsm->getReflectionClass()->getName(),
114	2	$dto
115		);
116		}
117
118		/**
119		* Generate an Entity. Optionally provide an offset from the first entity
120		*
121		* @return EntityInterface
122		* @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
123		* @throws \ErrorException
124		* @throws \ReflectionException
125		* @SuppressWarnings(PHPMD.StaticAccess)
126		*/
127	3	public function generateEntity(): EntityInterface
128		{
129	3	return $this->createEntityWithData();
130		}
131
132	3	private function createEntityWithData(): EntityInterface
133		{
134	3	$dto = $this->generateDto();
135
136	3	return $this->entityFactory->create($this->testedEntityDsm->getReflectionClass()->getName(), $dto);
137		}
138
139	5	public function generateDto(): DataTransferObjectInterface
140		{
141	5	$dto = $this->dtoFactory->createEmptyDtoFromEntityFqn(
142	5	$this->testedEntityDsm->getReflectionClass()->getName()
143		);
144	5	$this->fakerUpdateDto($dto);
145
146	5	return $dto;
147		}
148
149	5	public function fakerUpdateDto(DataTransferObjectInterface $dto): void
150		{
151	5	$this->fakerDataFiller->updateDtoWithFakeData($dto);
152	5	}
153
154		/**
155		* @param EntityInterface $generated
156		*
157		* @throws \ErrorException
158		* @SuppressWarnings(PHPMD.ElseExpression)
159		* @SuppressWarnings(PHPMD.CyclomaticComplexity)
160		*/
161	1	public function addAssociationEntities(
162		EntityInterface $generated
163		): void {
164	1	$testedEntityReflection = $this->testedEntityDsm->getReflectionClass();
165	1	$class = $testedEntityReflection->getName();
166	1	$meta = $this->testedEntityDsm->getMetaData();
167	1	$mappings = $meta->getAssociationMappings();
168	1	if (empty($mappings)) {
169		return;
170		}
171	1	$namespaceHelper = new NamespaceHelper();
172	1	$methods = array_map('strtolower', get_class_methods($generated));
173	1	foreach ($mappings as $mapping) {
174	1	$mappingEntityFqn = $mapping['targetEntity'];
175	1	$errorMessage = "Error adding association entity $mappingEntityFqn to $class: %s";
176		$mappingEntityPluralInterface =
177	1	$namespaceHelper->getHasPluralInterfaceFqnForEntity($mappingEntityFqn);
178		$mappingEntityPluralInterfaceRequired =
179	1	str_replace('\\Has', '\\HasRequired', $mappingEntityPluralInterface);
180	1	if ((\interface_exists($mappingEntityPluralInterface) &&
181	1	$testedEntityReflection->implementsInterface($mappingEntityPluralInterface))
182		\|\|
183	1	(\interface_exists($mappingEntityPluralInterfaceRequired)
184	1	&& $testedEntityReflection->implementsInterface($mappingEntityPluralInterfaceRequired))
185		) {
186	1	$this->assertSame(
187	1	$mappingEntityFqn::getDoctrineStaticMeta()->getPlural(),
188	1	$mapping['fieldName'],
189	1	sprintf($errorMessage, ' mapping should be plural')
190		);
191	1	$getter = 'get' . $mappingEntityFqn::getDoctrineStaticMeta()->getPlural();
192	1	$method = 'add' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
193		} else {
194	1	$this->assertSame(
195	1	$mappingEntityFqn::getDoctrineStaticMeta()->getSingular(),
196	1	$mapping['fieldName'],
197	1	sprintf($errorMessage, ' mapping should be singular')
198		);
199	1	$getter = 'get' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
200	1	$method = 'set' . $mappingEntityFqn::getDoctrineStaticMeta()->getSingular();
201		}
202	1	$this->assertInArray(
203	1	strtolower($method),
204	1	$methods,
205	1	sprintf($errorMessage, $method . ' method is not defined')
206		);
207		try {
208	1	$currentlySet = $generated->$getter();
209		} catch (\TypeError $e) {
210		$currentlySet = null;
211		}
212	1	$this->addAssociation($generated, $method, $mappingEntityFqn, $currentlySet);
213		}
214	1	}
215
216		/**
217		* Stub of PHPUnit Assertion method
218		*
219		* @param mixed $expected
220		* @param mixed $actual
221		* @param string $error
222		*
223		* @throws \ErrorException
224		*/
225	1	protected function assertSame($expected, $actual, string $error): void
226		{
227	1	if ($expected !== $actual) {
228		throw new \ErrorException($error);
229		}
230	1	}
231
232		/**
233		* Stub of PHPUnit Assertion method
234		*
235		* @param mixed $needle
236		* @param array $haystack
237		* @param string $error
238		*
239		* @throws \ErrorException
240		*/
241	1	protected function assertInArray($needle, array $haystack, string $error): void
242		{
243	1	if (false === \in_array($needle, $haystack, true)) {
244		throw new \ErrorException($error);
245		}
246	1	}
247
248	1	private function addAssociation(
249		EntityInterface $generated,
250		string $setOrAddMethod,
251		string $mappingEntityFqn,
252		$currentlySet
253		): void {
254	1	$testEntityGenerator = $this->testEntityGeneratorFactory
255	1	->createForEntityFqn($mappingEntityFqn);
256	1	switch (true) {
257		case $currentlySet === null:
258	1	case $currentlySet === []:
259	1	case $currentlySet instanceof Collection:
260	1	$mappingEntity = $testEntityGenerator->createEntityRelatedToEntity($generated);
261	1	break;
262		default:
263		return;
264		}
265	1	$generated->$setOrAddMethod($mappingEntity);
266	1	$this->entityManager->persist($mappingEntity);
267	1	}
268
269		/**
270		* @param EntityInterface $entity
271		*
272		* @return mixed
273		* @SuppressWarnings(PHPMD.UnusedPrivateMethod - it is being used)
274		*/
275	1	private function createEntityRelatedToEntity(EntityInterface $entity)
276		{
277	1	$dto = $this->generateDtoRelatedToEntity($entity);
278
279	1	return $this->entityFactory->create(
280	1	$this->testedEntityDsm->getReflectionClass()->getName(),
281	1	$dto
282		);
283		}
284
285	1	public function generateDtoRelatedToEntity(EntityInterface $entity): DataTransferObjectInterface
286		{
287	1	$dto = $this->dtoFactory->createDtoRelatedToEntityInstance(
288	1	$entity,
289	1	$this->testedEntityDsm->getReflectionClass()->getName()
290		);
291	1	$this->fakerDataFiller->updateDtoWithFakeData($dto);
292
293	1	return $dto;
294		}
295
296		/**
297		* Generate Entities.
298		*
299		* Optionally discard the first generated entities up to the value of offset
300		*
301		* @param int $num
302		*
303		* @return array\|EntityInterface[]
304		*/
305	1	public function generateEntities(
306		int $num
307		): array {
308	1	$entities = [];
309	1	$generator = $this->getGenerator($num);
310	1	foreach ($generator as $entity) {
311	1	$id = (string)$entity->getId();
312	1	if (array_key_exists($id, $entities)) {
313		throw new \RuntimeException('Entity with ID ' . $id . ' is already generated');
314		}
315	1	$entities[$id] = $entity;
316		}
317
318	1	return $entities;
319		}
320
321	2	public function getGenerator(int $numToGenerate = 100): \Generator
322		{
323	2	$entityFqn = $this->testedEntityDsm->getReflectionClass()->getName();
324	2	$generated = 0;
325	2	while ($generated < $numToGenerate) {
326	2	$dto = $this->generateDto();
327	2	$entity = $this->entityFactory->setEntityManager($this->entityManager)->create($entityFqn, $dto);
328	2	yield $entity;
329	2	$generated++;
330		}
331	1	}
332
333		/**
334		* @return EntityFactoryInterface
335		*/
336		public function getEntityFactory(): EntityFactoryInterface
337		{
338		return $this->entityFactory;
339		}
340
341		/**
342		* @return DtoFactory
343		*/
344		public function getDtoFactory(): DtoFactory
345		{
346		return $this->dtoFactory;
347		}
348
349		/**
350		* @return FakerDataFiller
351		*/
352		public function getFakerDataFiller(): FakerDataFiller
353		{
354		return $this->fakerDataFiller;
355		}
356
357		/**
358		* @return EntityManagerInterface
359		*/
360		public function getEntityManager(): EntityManagerInterface
361		{
362		return $this->entityManager;
363		}
364
365		/**
366		* @return TestEntityGeneratorFactory
367		*/
368		public function getTestEntityGeneratorFactory(): TestEntityGeneratorFactory
369		{
370		return $this->testEntityGeneratorFactory;
371		}
372		}
373

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Push — master ( 0d13eb...0e53de )

TestEntityGenerator::generateDtoRelatedToEntity() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like