AbstractFieldTraitLargeTest::getFakerDataProvider() - Code Metrics - Inspection of "Refactor and optimise tests" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#101)

by joseph

created 2018-08-22 19:51 UTC

getFakerDataProvider() A

↳ Parent: AbstractFieldTraitLargeTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	9
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Tests\Large\Entity\Fields\Traits;

use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\FakerDataProviderInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\EntitySaver;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityTestInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Validation\EntityValidatorFactory;
use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractLargeTest;
use Faker\Generator;

/**
 * Extend this test with your Field Trait test to get basic test coverage.
 *
 * You should extend your field trait test to test your validation
 *
 * Class AbstractFieldTraitLargeTest
 *
 * @package EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits
 * @SuppressWarnings(PHPMD.NumberOfChildren)
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @large
 */
abstract class AbstractFieldTraitLargeTest extends AbstractLargeTest
{
    protected const TEST_ENTITY_FQN_BASE = self::TEST_PROJECT_ROOT_NAMESPACE
                                           . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME
                                           . '\\';

    protected const TEST_FIELD_FQN = 'Override Me';

    /**
     * The expected default value for the field. Most fields are marked as nullable so the default is null.
     * Should be overriden in the actual field test for any fields that are not nullable
     */
    protected const TEST_FIELD_DEFAULT = null;

    protected const TEST_FIELD_PROP = 'Override Me';

    /**
     * set to false for read only fields (with no setter)
     */
    protected const HAS_SETTER = true;
    /**
     * @var Generator
     */
    protected static $fakerGenerator;
    protected $entitySuffix;

    /**
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public static function setUpBeforeClass()
    {
        parent::setUpBeforeClass();
        self::$fakerGenerator = \Faker\Factory::create();
    }

    public function setup()
    {
        parent::setup();
        $this->entitySuffix = substr(static::class, strrpos(static::class, '\\') + 1);
        $this->generateCode();
    }

    protected function generateCode()
    {
        $this->getEntityGenerator()
             ->generateEntity(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
        $this->getFieldSetter()
             ->setEntityHasField(
                 static::TEST_ENTITY_FQN_BASE . $this->entitySuffix,
                 static::TEST_FIELD_FQN
             );
    }

    /**
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ReflectionException
     * @large
     * @test
     * @coversNothing
     */
    public function createEntityWithField(): void
    {
        $this->setupCopiedWorkDir();
        $entityFqn = $this->getCopiedFqn(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
        $entity    = new $entityFqn($this->container->get(EntityValidatorFactory::class));
        $getter    = $this->getGetter($entity);
        self::assertTrue(\method_exists($entity, $getter));
        $value = $entity->$getter();
        self::assertSame(
            static::TEST_FIELD_DEFAULT,
            $value,
            'The getter on a newly created entity returns ' . var_export($value, true)
            . ' whereas the configured default value is ' . var_export(static::TEST_FIELD_DEFAULT, true)
        );
        if (false === static::HAS_SETTER) {

            return;
        }
        $setValue = $this->setFakerValueForProperty($entity);
        self::assertSame($setValue, $entity->$getter());
    }

    /**
     * @param EntityInterface $entity
     *
     * @return string
     * @throws \Exception
     */
    protected function getGetter(EntityInterface $entity): string
    {
        foreach (['get', 'is', 'has'] as $prefix) {
            $method = $prefix . static::TEST_FIELD_PROP;
            if (\method_exists($entity, $method)) {
                return $method;
            }
        }
        throw new \RuntimeException('Failed finding a getter in ' . __METHOD__);
    }

    /**
     * @param EntityInterface $entity
     *
     * @return mixed
     * @throws \ReflectionException
     * @throws \Exception
     */
    protected function setFakerValueForProperty(EntityInterface $entity)
    {
        $setter        = 'set' . static::TEST_FIELD_PROP;
        $fakerProvider = $this->getFakerDataProvider();
        if ($fakerProvider instanceof FakerDataProviderInterface) {
            $setValue = $fakerProvider();
            $entity->$setter($setValue);

            return $setValue;
        }
        $reflection       = new  \ts\Reflection\ReflectionClass(\get_class($entity));
        $setterReflection = $reflection->getMethod($setter);
        $setParamType     = current($setterReflection->getParameters())->getType()->getName();
        switch ($setParamType) {
            case 'string':
                $setValue = self::$fakerGenerator->text();
                break;
            case 'int':
                $setValue = self::$fakerGenerator->numberBetween(0, PHP_INT_MAX);
                break;
            case 'float':
                $setValue = self::$fakerGenerator->randomFloat(12, 0, 10000);
                break;
            case 'bool':
                $setValue = self::$fakerGenerator->boolean;
                break;
            case 'DateTime':
                $setValue = self::$fakerGenerator->dateTime;
                break;
            case 'DateTimeImmutable':
                $setValue = new \DateTimeImmutable(
                    self::$fakerGenerator->dateTime->format('Y-m-d')
                );
                break;
            default:
                throw new \RuntimeException('Failed getting a data provider for the property type ' . $setParamType);
        }
        $entity->$setter($setValue);

        return $setValue;
    }

    protected function getFakerDataProvider(): ?FakerDataProviderInterface
    {
        if (isset(EntityTestInterface::FAKER_DATA_PROVIDERS[static::TEST_FIELD_PROP])) {
            $provider = EntityTestInterface::FAKER_DATA_PROVIDERS[static::TEST_FIELD_PROP];

            return new $provider(self::$fakerGenerator);
        }

        return null;
    }

    /**
     * @test
     * @large
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ReflectionException
     * @coversNothing
     */
    public function createDatabaseSchema()
    {
        $this->setupCopiedWorkDirAndCreateDatabase();
        $entityManager = $this->getEntityManager();
        $entityFqn     = $this->getCopiedFqn(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
        $entity        = new $entityFqn($this->container->get(EntityValidatorFactory::class));
        $setValue      = null;
        if (false !== static::HAS_SETTER) {

            $setValue = $this->setFakerValueForProperty($entity);
        }
        $saver = $this->container->get(EntitySaver::class);
        $saver->save($entity);
        $repository  = $entityManager->getRepository($entityFqn);
        $entities    = $repository->findAll();
        $savedEntity = current($entities);
        $getter      = $this->getGetter($entity);
        $gotValue    = $savedEntity->$getter();
        if (false !== static::HAS_SETTER) {

            self::assertEquals($setValue, $gotValue);

            return;
        }
        self::assertNotNull($gotValue);
    }
}


1			<?php declare(strict_types=1);
2
3			namespace EdmondsCommerce\DoctrineStaticMeta\Tests\Large\Entity\Fields\Traits;
4
5			use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
6			use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\FakerDataProviderInterface;
7			use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
8			use EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\EntitySaver;
9			use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityTestInterface;
10			use EdmondsCommerce\DoctrineStaticMeta\Entity\Validation\EntityValidatorFactory;
11			use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractLargeTest;
12			use Faker\Generator;
13
14			/**
15			* Extend this test with your Field Trait test to get basic test coverage.
16			*
17			* You should extend your field trait test to test your validation
18			*
19			* Class AbstractFieldTraitLargeTest
20			*
21			* @package EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits
22			* @SuppressWarnings(PHPMD.NumberOfChildren)
23			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
24			* @large
25			*/
26			abstract class AbstractFieldTraitLargeTest extends AbstractLargeTest
27			{
28			protected const TEST_ENTITY_FQN_BASE = self::TEST_PROJECT_ROOT_NAMESPACE
29			. '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME
30			. '\\';
31
32			protected const TEST_FIELD_FQN = 'Override Me';
33
34			/**
35			* The expected default value for the field. Most fields are marked as nullable so the default is null.
36			* Should be overriden in the actual field test for any fields that are not nullable
37			*/
38			protected const TEST_FIELD_DEFAULT = null;
39
40			protected const TEST_FIELD_PROP = 'Override Me';
41
42			/**
43			* set to false for read only fields (with no setter)
44			*/
45			protected const HAS_SETTER = true;
46			/**
47			* @var Generator
48			*/
49			protected static $fakerGenerator;
50			protected $entitySuffix;
51
52			/**
53			* @SuppressWarnings(PHPMD.StaticAccess)
54			*/
55			public static function setUpBeforeClass()
56			{
57			parent::setUpBeforeClass();
58			self::$fakerGenerator = \Faker\Factory::create();
59			}
60
61			public function setup()
62			{
63			parent::setup();
64			$this->entitySuffix = substr(static::class, strrpos(static::class, '\\') + 1);
65			$this->generateCode();
66			}
67
68			protected function generateCode()
69			{
70			$this->getEntityGenerator()
71			->generateEntity(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
72			$this->getFieldSetter()
73			->setEntityHasField(
74			static::TEST_ENTITY_FQN_BASE . $this->entitySuffix,
75			static::TEST_FIELD_FQN
76			);
77			}
78
79			/**
80			* @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
81			* @throws \ReflectionException
82			* @large
83			* @test
84			* @coversNothing
85			*/
86			public function createEntityWithField(): void
87			{
88			$this->setupCopiedWorkDir();
89			$entityFqn = $this->getCopiedFqn(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
90			$entity = new $entityFqn($this->container->get(EntityValidatorFactory::class));
91			$getter = $this->getGetter($entity);
92			self::assertTrue(\method_exists($entity, $getter));
93			$value = $entity->$getter();
94			self::assertSame(
95			static::TEST_FIELD_DEFAULT,
96			$value,
97			'The getter on a newly created entity returns ' . var_export($value, true)
98			. ' whereas the configured default value is ' . var_export(static::TEST_FIELD_DEFAULT, true)
99			);
100			if (false === static::HAS_SETTER) {
			0 ignored issues – show introduced 2018-06-25 14:46 UTC by Report Bug Copy Issue Report The condition `false === static::HAS_SETTER` is always `false`. Loading history...
101			return;
102			}
103			$setValue = $this->setFakerValueForProperty($entity);
104			self::assertSame($setValue, $entity->$getter());
105			}
106
107			/**
108			* @param EntityInterface $entity
109			*
110			* @return string
111			* @throws \Exception
112			*/
113			protected function getGetter(EntityInterface $entity): string
114			{
115			foreach (['get', 'is', 'has'] as $prefix) {
116			$method = $prefix . static::TEST_FIELD_PROP;
117			if (\method_exists($entity, $method)) {
118			return $method;
119			}
120			}
121			throw new \RuntimeException('Failed finding a getter in ' . __METHOD__);
122			}
123
124			/**
125			* @param EntityInterface $entity
126			*
127			* @return mixed
128			* @throws \ReflectionException
129			* @throws \Exception
130			*/
131			protected function setFakerValueForProperty(EntityInterface $entity)
132			{
133			$setter = 'set' . static::TEST_FIELD_PROP;
134			$fakerProvider = $this->getFakerDataProvider();
135			if ($fakerProvider instanceof FakerDataProviderInterface) {
136			$setValue = $fakerProvider();
137			$entity->$setter($setValue);
138
139			return $setValue;
140			}
141			$reflection = new \ts\Reflection\ReflectionClass(\get_class($entity));
142			$setterReflection = $reflection->getMethod($setter);
143			$setParamType = current($setterReflection->getParameters())->getType()->getName();
144			switch ($setParamType) {
145			case 'string':
146			$setValue = self::$fakerGenerator->text();
147			break;
148			case 'int':
149			$setValue = self::$fakerGenerator->numberBetween(0, PHP_INT_MAX);
150			break;
151			case 'float':
152			$setValue = self::$fakerGenerator->randomFloat(12, 0, 10000);
153			break;
154			case 'bool':
155			$setValue = self::$fakerGenerator->boolean;
156			break;
157			case 'DateTime':
158			$setValue = self::$fakerGenerator->dateTime;
159			break;
160			case 'DateTimeImmutable':
161			$setValue = new \DateTimeImmutable(
162			self::$fakerGenerator->dateTime->format('Y-m-d')
163			);
164			break;
165			default:
166			throw new \RuntimeException('Failed getting a data provider for the property type ' . $setParamType);
167			}
168			$entity->$setter($setValue);
169
170			return $setValue;
171			}
172
173			protected function getFakerDataProvider(): ?FakerDataProviderInterface
174			{
175			if (isset(EntityTestInterface::FAKER_DATA_PROVIDERS[static::TEST_FIELD_PROP])) {
176			$provider = EntityTestInterface::FAKER_DATA_PROVIDERS[static::TEST_FIELD_PROP];
177
178			return new $provider(self::$fakerGenerator);
179			}
180
181			return null;
182			}
183
184			/**
185			* @test
186			* @large
187			* @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
188			* @throws \ReflectionException
189			* @coversNothing
190			*/
191			public function createDatabaseSchema()
192			{
193			$this->setupCopiedWorkDirAndCreateDatabase();
194			$entityManager = $this->getEntityManager();
195			$entityFqn = $this->getCopiedFqn(static::TEST_ENTITY_FQN_BASE . $this->entitySuffix);
196			$entity = new $entityFqn($this->container->get(EntityValidatorFactory::class));
197			$setValue = null;
198			if (false !== static::HAS_SETTER) {
			0 ignored issues – show introduced 2018-06-25 14:46 UTC by Report Bug Copy Issue Report The condition `false !== static::HAS_SETTER` is always `true`. Loading history...
199			$setValue = $this->setFakerValueForProperty($entity);
200			}
201			$saver = $this->container->get(EntitySaver::class);
202			$saver->save($entity);
203			$repository = $entityManager->getRepository($entityFqn);
204			$entities = $repository->findAll();
205			$savedEntity = current($entities);
206			$getter = $this->getGetter($entity);
207			$gotValue = $savedEntity->$getter();
208			if (false !== static::HAS_SETTER) {
			0 ignored issues – show introduced 2018-06-25 14:46 UTC by Report Bug Copy Issue Report The condition `false !== static::HAS_SETTER` is always `true`. Loading history...
209			self::assertEquals($setValue, $gotValue);
210
211			return;
212			}
213			self::assertNotNull($gotValue);
214			}
215			}
216

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#101)

getFakerDataProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like