TestEntityGenerator::generateDto() - Code Metrics - Inspection of "Mess detector fixes" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#214)

by joseph

created 2019-08-14 10:39 UTC

TestEntityGenerator::generateDto() A

↳ Parent: TestEntityGenerator

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	8
ccs	0
cts	7
cp	0
crap	2
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;
use EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException;
use ErrorException;
use Generator;
use ReflectionException;
use RuntimeException;
use TypeError;
use function in_array;
use function interface_exists;

/**
 * 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 FakerDataFillerInterface
     */
    private $fakerDataFiller;


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

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#214)

TestEntityGenerator::generateDto() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like