AbstractEntityTest::assertCorrectMapping() - Code Metrics - Inspection of "Required relations" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#152)

by joseph
created 2018-10-29 17:36 UTC
AbstractEntityTest::assertCorrectMapping() A

↳ Parent: AbstractEntityTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	50
Code Lines	39
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes
Metric	Value
cc	2
eloc	39
nc	2
nop	3
dl	0
loc	50
ccs	0
cts	48
cp	0
crap	6
rs	9.296
c	0
b	0
f	0
<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Testing;

use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Tools\SchemaValidator;
use Doctrine\ORM\Utility\PersisterHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\CodeHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\RelationsGenerator;
use EdmondsCommerce\DoctrineStaticMeta\Config;
use EdmondsCommerce\DoctrineStaticMeta\ConfigInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\DataTransferObjects\DtoFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Embeddable\Objects\AbstractEmbeddableObject;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Interfaces\PrimaryKey\IdFieldInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories\RepositoryFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\EntitySaverFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\EntitySaverInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityGenerator\TestEntityGenerator;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityGenerator\TestEntityGeneratorFactory;
use EdmondsCommerce\DoctrineStaticMeta\Exception\ConfigException;
use EdmondsCommerce\DoctrineStaticMeta\MappingHelper;
use EdmondsCommerce\DoctrineStaticMeta\SimpleEnv;
use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerInterface;

/**
 * Class AbstractEntityTest
 *
 * This abstract test is designed to give you a good level of test coverage for your entities without any work required.
 *
 * You should extend the test with methods that test your specific business logic, your validators and anything else.
 *
 * You can override the methods, properties and constants as you see fit.
 *
 * @package EdmondsCommerce\DoctrineStaticMeta\Entity
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.NumberOfChildren)
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 * @SuppressWarnings(PHPMD.StaticAccess)
 */
abstract class AbstractEntityTest extends TestCase implements EntityTestInterface
{
    /**
     * @var ContainerInterface
     */
    protected static $container;
    /**
     * The fully qualified name of the Entity being tested, as calculated by the test class name
     *
     * @var string
     */
    protected static $testedEntityFqn;

    /**
     * @var TestEntityGenerator
     */
    protected static $testEntityGenerator;

    /**
     * @var array
     */
    protected static $schemaErrors = [];

    public static function setUpBeforeClass(): void
    {
        if (null !== static::$container) {
            self::tearDownAfterClass();
        }
        static::initContainer();
        static::$testedEntityFqn     = \substr(static::class, 0, -4);
        static::$testEntityGenerator = static::$container->get(TestEntityGeneratorFactory::class)
                                                         ->createForEntityFqn(static::$testedEntityFqn);
    }

    public static function tearDownAfterClass()
    {
        $entityManager = static::$container->get(EntityManagerInterface::class);
        $entityManager->close();
        $entityManager->getConnection()->close();
        self::$container   = null;
        static::$container = null;
    }

    public static function initContainer(): void
    {
        $testConfig        = self::getTestContainerConfig();
        static::$container = TestContainerFactory::getContainer($testConfig);
    }

    /**
     * @throws ConfigException
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @SuppressWarnings(PHPMD.Superglobals)
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    protected static function getTestContainerConfig(): array
    {
        SimpleEnv::setEnv(Config::getProjectRootDirectory() . '/.env');
        $testConfig                                 = $_SERVER;
        $testConfig[ConfigInterface::PARAM_DB_NAME] = $_SERVER[ConfigInterface::PARAM_DB_NAME] . '_test';

        return $testConfig;
    }

    /**
     * @test
     * Use Doctrine's built in schema validation tool to catch issues
     */
    public function theSchemaIsValidForThisEntity()
    {
        $errors  = $this->getSchemaErrors();
        $message = '';
        if (isset($errors[static::$testedEntityFqn])) {
            $message = "Failed ORM Validate Schema:\n";
            foreach ($errors[static::$testedEntityFqn] as $err) {
                $message .= "\n * $err \n";
            }
        }
        self::assertEmpty($message, $message);
    }

    /**
     * Use Doctrine's standard schema validation to get errors for the whole schema
     *
     * We cache this as a class property because the schema only needs validating once as a whole, after that we can
     * pull out Entity specific issues as required
     *
     * @param bool $update
     *
     * @return array
     * @throws \Exception
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    protected function getSchemaErrors(bool $update = false): array
    {
        if ([] === static::$schemaErrors || true === $update) {
            $validator            = new SchemaValidator($this->getEntityManager());
            static::$schemaErrors = $validator->validateMapping();
        }

        return static::$schemaErrors;
    }

    protected function getEntityManager(): EntityManagerInterface
    {
        return static::$container->get(EntityManagerInterface::class);
    }

    /**
     * Loop through Entity fields, call the getter and where possible assert there is a value returned
     *
     * @param EntityInterface $entity
     *
     * @return EntityInterface
     * @throws \Doctrine\ORM\Query\QueryException
     * @throws \ReflectionException
     * @SuppressWarnings(PHPMD.StaticAccess)
     * @test
     * @depends weCanGenerateANewEntityInstance
     */
    public function theEntityGettersReturnValues(EntityInterface $entity): EntityInterface
    {
        $meta = $this->getEntityManager()->getClassMetadata(static::$testedEntityFqn);
        $dto  = $this->getDtoFactory()->createDtoFromEntity($entity);
        foreach ($meta->getFieldNames() as $fieldName) {
            if ('id' === $fieldName) {
                continue;
            }
            $type   = PersisterHelper::getTypeOfField($fieldName, $meta, $this->getEntityManager())[0];
            $method = $this->getGetterNameForField($fieldName, $type);
            if (\ts\stringContains($method, '.')) {
                list($getEmbeddableMethod,) = explode('.', $method);
                $embeddable = $entity->$getEmbeddableMethod();
                self::assertInstanceOf(AbstractEmbeddableObject::class, $embeddable);
                continue;
            }
            $reflectionMethod = new \ReflectionMethod($entity, $method);
            if ($reflectionMethod->hasReturnType()) {
                $returnType = $reflectionMethod->getReturnType();
                $allowsNull = $returnType->allowsNull();
                if ($allowsNull) {
                    // As we can't assert anything here so simply call
                    // the method and allow the type hint to raise any
                    // errors.
                    $entity->$method();
                    continue;
                }
                self::assertNotNull($dto->$method(), "$fieldName getter returned null");
                continue;
            }
            // If there is no return type then we can't assert anything,
            // but again we can just call the getter to check for errors
            $dto->$method();
        }
        if (0 === $this->getCount()) {
            self::markTestSkipped('No assertable getters in this Entity');
        }

        return $entity;
    }

    protected function getDtoFactory(): DtoFactory
    {
        return static::$container->get(DtoFactory::class);
    }

    protected function getGetterNameForField(string $fieldName, string $type): string
    {
        if ($type === 'boolean') {
            return static::$container->get(CodeHelper::class)->getGetterMethodNameForBoolean($fieldName);
        }

        return 'get' . $fieldName;
    }

    /**
     * Test that we have correctly generated an instance of our test entity
     *
     * @return EntityInterface
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ErrorException
     * @throws \ReflectionException
     * @SuppressWarnings(PHPMD.StaticAccess)
     * @test
     */
    public function weCanGenerateANewEntityInstance(): EntityInterface
    {
        $generated = $this->getTestEntityGenerator()->generateEntity();
        self::assertInstanceOf(static::$testedEntityFqn, $generated);

        return $generated;
    }

    protected function getTestEntityGenerator(): TestEntityGenerator
    {
        return static::$testEntityGenerator;
    }

    /**
     * @param EntityInterface $generated
     *
     * @return EntityInterface
     * @test
     * @depends theEntityGettersReturnValues
     * @throws \ErrorException
     */
    public function weCanExtendTheEntityWithUnrequiredAssociationEntities(EntityInterface $generated): EntityInterface
    {
        if ([] === $this->getTestedEntityClassMetaData()->getAssociationMappings()) {
            $this->markTestSkipped('No associations to test');
        }
        $this->getTestEntityGenerator()->addAssociationEntities($generated);
        $this->assertAllAssociationsAreNotEmpty($generated);

        return $generated;
    }

    protected function getTestedEntityClassMetaData(): ClassMetadata
    {
        return $this->getEntityManager()->getClassMetadata(static::$testedEntityFqn);

    }

    protected function assertAllAssociationsAreNotEmpty(EntityInterface $entity)
    {
        $meta = $this->getTestedEntityClassMetaData();
        foreach ($meta->getAssociationMappings() as $mapping) {
            $getter = 'get' . $mapping['fieldName'];
            if ($meta->isCollectionValuedAssociation($mapping['fieldName'])) {
                $collection = $entity->$getter()->toArray();
                $this->assertCorrectMappings(static::$testedEntityFqn, $mapping);
                self::assertNotEmpty(
                    $collection,
                    'Failed to load the collection of the associated entity [' . $mapping['fieldName']
                    . '] from the generated ' . static::$testedEntityFqn
                    . ', make sure you have reciprocal adding of the association'
                );

                continue;
            }
            $association = $entity->$getter();
            self::assertNotEmpty(
                $association,
                'Failed to load the associated entity: [' . $mapping['fieldName']
                . '] from the generated ' . static::$testedEntityFqn
            );
            self::assertNotEmpty(
                $association->getId(),
                'Failed to get the ID of the associated entity: [' . $mapping['fieldName']
                . '] from the generated ' . static::$testedEntityFqn
            );
        }
    }

    /**
     * Check the mapping of our class and the associated entity to make sure it's configured properly on both sides.
     * Very easy to get wrong. This is in addition to the standard Schema Validation
     *
     * @param string $classFqn
     * @param array  $mapping
     */
    protected function assertCorrectMappings(string $classFqn, array $mapping)
    {
        $entityManager                        = $this->getEntityManager();
        $pass                                 = false;
        $associationFqn                       = $mapping['targetEntity'];
        $associationMeta                      = $entityManager->getClassMetadata($associationFqn);
        $classTraits                          = $entityManager->getClassMetadata($classFqn)
                                                              ->getReflectionClass()
                                                              ->getTraits();
        $unidirectionalTraitShortNamePrefixes = [
            'Has' . $associationFqn::getDoctrineStaticMeta()->getSingular() . RelationsGenerator::PREFIX_UNIDIRECTIONAL,
            'Has' . $associationFqn::getDoctrineStaticMeta()->getPlural() . RelationsGenerator::PREFIX_UNIDIRECTIONAL,
            'Has' . RelationsGenerator::PREFIX_REQUIRED .
            $associationFqn::getDoctrineStaticMeta()->getSingular() . RelationsGenerator::PREFIX_UNIDIRECTIONAL,
            'Has' . RelationsGenerator::PREFIX_REQUIRED .
            $associationFqn::getDoctrineStaticMeta()->getPlural() . RelationsGenerator::PREFIX_UNIDIRECTIONAL,
        ];
        foreach ($classTraits as $trait) {
            foreach ($unidirectionalTraitShortNamePrefixes as $namePrefix) {
                if (0 === \stripos($trait->getShortName(), $namePrefix)) {
                    return;
                }
            }
        }
        foreach ($associationMeta->getAssociationMappings() as $associationMapping) {
        foreach ($associationMeta->/** @scrutinizer ignore-call */ getAssociationMappings() as $associationMapping) {
            if ($classFqn === $associationMapping['targetEntity']) {
                $pass = $this->assertCorrectMapping($mapping, $associationMapping, $classFqn);
                break;
            }
        }
        self::assertTrue(
            $pass,
            'Failed finding association mapping to test for ' . "\n" . $mapping['targetEntity']
        );
    }

    /**
     * @param array  $mapping
     * @param array  $associationMapping
     * @param string $classFqn
     *
     * @return bool
     */
    protected function assertCorrectMapping(array $mapping, array $associationMapping, string $classFqn): bool
    {
        if (empty($mapping['joinTable'])) {
            self::assertArrayNotHasKey(
                'joinTable',
                $associationMapping,
                $classFqn . ' join table is empty,
                        but association ' . $mapping['targetEntity'] . ' join table is not empty'
            );

            return true;
        }
        self::assertNotEmpty(
            $associationMapping['joinTable'],
            "$classFqn joinTable is set to " . $mapping['joinTable']['name']
            . " \n association " . $mapping['targetEntity'] . ' join table is empty'
        );
        self::assertSame(
            $mapping['joinTable']['name'],
            $associationMapping['joinTable']['name'],
            "join tables not the same: \n * $classFqn = " . $mapping['joinTable']['name']
            . " \n * association " . $mapping['targetEntity']
            . ' = ' . $associationMapping['joinTable']['name']
        );
        self::assertArrayHasKey(
            'inverseJoinColumns',
            $associationMapping['joinTable'],
            "join table join columns not the same: \n * $classFqn joinColumn = "
            . $mapping['joinTable']['joinColumns'][0]['name']
            . " \n * association " . $mapping['targetEntity']
            . ' inverseJoinColumn is not set'
        );
        self::assertSame(
            $mapping['joinTable']['joinColumns'][0]['name'],
            $associationMapping['joinTable']['inverseJoinColumns'][0]['name'],
            "join table join columns not the same: \n * $classFqn joinColumn = "
            . $mapping['joinTable']['joinColumns'][0]['name']
            . " \n * association " . $mapping['targetEntity']
            . ' inverseJoinColumn = ' . $associationMapping['joinTable']['inverseJoinColumns'][0]['name']
        );
        self::assertSame(
            $mapping['joinTable']['inverseJoinColumns'][0]['name'],
            $associationMapping['joinTable']['joinColumns'][0]['name'],
            "join table join columns  not the same: \n * $classFqn inverseJoinColumn = "
            . $mapping['joinTable']['inverseJoinColumns'][0]['name']
            . " \n * association " . $mapping['targetEntity'] . ' joinColumn = '
            . $associationMapping['joinTable']['joinColumns'][0]['name']
        );

        return true;
    }

    /**
     * @param EntityInterface $generated
     *
     * @return EntityInterface
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ReflectionException
     * @test
     * @depends weCanExtendTheEntityWithUnrequiredAssociationEntities
     */
    public function theEntityCanBeSavedAndReloadedFromTheDatabase(EntityInterface $generated): EntityInterface
    {
        $this->getEntitySaver()->save($generated);
        $loaded = $this->loadEntity($generated->getId());
        self::assertSame((string)$generated->getId(), (string)$loaded->getId());
        self::assertInstanceOf(static::$testedEntityFqn, $loaded);

        return $loaded;
    }

    protected function getEntitySaver(): EntitySaverInterface
    {
        return static::$container->get(EntitySaverFactory::class)->getSaverForEntityFqn(static::$testedEntityFqn);
    }

    /**
     * @param mixed $id
     *
     * @return EntityInterface|null
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     */
    protected function loadEntity($id): EntityInterface
    {
        return static::$container->get(RepositoryFactory::class)
                                 ->getRepository(static::$testedEntityFqn)
                                 ->get($id);
    }

    /**
     * @param EntityInterface $loaded
     *
     * @return EntityInterface
     * @throws ConfigException
     * @throws \Doctrine\ORM\Query\QueryException
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ErrorException
     * @throws \ReflectionException
     * @depends theEntityCanBeSavedAndReloadedFromTheDatabase
     * @test
     */
    public function theLoadedEntityCanBeUpdatedAndResaved(EntityInterface $loaded): EntityInterface
    {
        $this->updateEntityFields($loaded);
        $this->assertAllAssociationsAreNotEmpty($loaded);
        $this->removeAllAssociations($loaded);
        $this->getEntitySaver()->save($loaded);

        return $loaded;
    }

    /**
     * Generate a new entity and then update our Entity with the values from the generated one
     *
     * @param EntityInterface $entity
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    protected function updateEntityFields(EntityInterface $entity): void
    {
        $dto = $this->getDtoFactory()->createDtoFromEntity($entity);
        $this->getTestEntityGenerator()->fakerUpdateDto($dto);
        $entity->update($dto);
    }

    /**
     * @param EntityInterface $entity
     *
     * @throws \ReflectionException
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    protected function removeAllAssociations(EntityInterface $entity)
    {
        $required    = $entity::getDoctrineStaticMeta()->getRequiredRelationProperties();
        $meta        = $this->getTestedEntityClassMetaData();
        $identifiers = array_flip($meta->getIdentifier());
        foreach ($meta->getAssociationMappings() as $mapping) {
            if (isset($identifiers[$mapping['fieldName']])) {
                continue;
            }
            if (isset($required[$mapping['fieldName']])) {
                continue;
            }
            $remover = 'remove' . MappingHelper::singularize($mapping['fieldName']);
            if ($meta->isCollectionValuedAssociation($mapping['fieldName'])) {
                $getter    = 'get' . $mapping['fieldName'];
                $relations = $entity->$getter();
                foreach ($relations as $relation) {
                    $entity->$remover($relation);
                }
                continue;
            }
            $entity->$remover();
        }
        $this->assertAllAssociationsAreEmpty($entity);
    }

    protected function assertAllAssociationsAreEmpty(EntityInterface $entity)
    {
        $required    = $entity::getDoctrineStaticMeta()->getRequiredRelationProperties();
        $meta        = $this->getTestedEntityClassMetaData();
        $identifiers = array_flip($meta->getIdentifier());
        foreach ($meta->getAssociationMappings() as $mapping) {
            if (isset($identifiers[$mapping['fieldName']])) {
                continue;
            }
            if (isset($required[$mapping['fieldName']])) {
                continue;
            }

            $getter = 'get' . $mapping['fieldName'];
            if ($meta->isCollectionValuedAssociation($mapping['fieldName'])) {
                $collection = $entity->$getter()->toArray();
                self::assertEmpty(
                    $collection,
                    'Collection of the associated entity [' . $mapping['fieldName']
                    . '] is not empty after calling remove'
                );
                continue;
            }
            $association = $entity->$getter();
            self::assertEmpty(
                $association,
                'Failed to remove associated entity: [' . $mapping['fieldName']
                . '] from the generated ' . static::$testedEntityFqn
            );
        }
    }

    /**
     * @param EntityInterface $entity
     *
     * @return EntityInterface
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @depends theLoadedEntityCanBeUpdatedAndResaved
     * @test
     */
    public function theReloadedEntityHasNoAssociatedEntities(EntityInterface $entity): EntityInterface
    {
        $reLoaded     = $this->loadEntity($entity->getId());
        $entityDump   = $this->dump($entity);
        $reLoadedDump = $this->dump($reLoaded);
        self::assertEquals($entityDump, $reLoadedDump);
        $this->assertAllAssociationsAreEmpty($reLoaded);

        return $reLoaded;
    }

    protected function dump(EntityInterface $entity): string
    {
        return (new EntityDebugDumper())->dump($entity, $this->getEntityManager());
    }

    /**
     * @depends weCanGenerateANewEntityInstance
     *
     * @param EntityInterface $entity
     *
     * @test
     */
    public function checkAllGettersCanBeReturnedFromDoctrineStaticMeta(EntityInterface $entity)
    {
        $getters = $entity::getDoctrineStaticMeta()->getGetters();
        self::assertNotEmpty($getters);
        foreach ($getters as $getter) {
            self::assertRegExp('%^(get|is|has).+%', $getter);
        }
    }

    /**
     * @depends weCanGenerateANewEntityInstance
     * @test
     *
     * @param EntityInterface $entity
     */
    public function checkAllSettersCanBeReturnedFromDoctrineStaticMeta(EntityInterface $entity)
    {
        $setters = $entity::getDoctrineStaticMeta()->getSetters();
        self::assertNotEmpty($setters);
        foreach ($setters as $setter) {
            self::assertRegExp('%^(set|add).+%', $setter);
        }
    }

    /**
     * Loop through entity fields and find unique ones
     *
     * Then ensure that the unique rule is being enforced as expected
     *
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ErrorException
     * @throws \ReflectionException
     * @test
     * @depends theReloadedEntityHasNoAssociatedEntities
     */
    public function checkThatWeCanNotSaveEntitiesWithDuplicateUniqueFieldValues(): void
    {
        $meta         = $this->getTestedEntityClassMetaData();
        $uniqueFields = [];
        foreach ($meta->getFieldNames() as $fieldName) {
            if (IdFieldInterface::PROP_ID === $fieldName) {
                continue;
            }
            if (true === $this->isUniqueField($fieldName)) {
                $uniqueFields[] = $fieldName;
            }
        }
        if ([] === $uniqueFields) {
            self::markTestSkipped('No unique fields to check');

            return;
        }
        foreach ($uniqueFields as $fieldName) {
            $primary      = $this->getTestEntityGenerator()->generateEntity();
            $secondary    = $this->getTestEntityGenerator()->generateEntity();
            $secondaryDto = $this->getDtoFactory()->createDtoFromEntity($secondary);
            $getter       = 'get' . $fieldName;
            $setter       = 'set' . $fieldName;
            $primaryValue = $primary->$getter();
            $secondaryDto->$setter($primaryValue);
            $secondary->update($secondaryDto);
            $saver = $this->getEntitySaver();
            $this->expectException(UniqueConstraintViolationException::class);
            $saver->saveAll([$primary, $secondary]);
        }
    }

    protected function isUniqueField(string $fieldName): bool
    {
        $fieldMapping = $this->getTestedEntityClassMetaData()->getFieldMapping($fieldName);

        return array_key_exists('unique', $fieldMapping) && true === $fieldMapping['unique'];
    }
}

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#152)

AbstractEntityTest::assertCorrectMapping() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
