FixtureLoaderAndHelperTest::itCanBeConfiguredNotToLoadFromTheCache() - Code Metrics - Inspection of "Merge pull request #148 from edmondscommerce/Fixin..." - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 75bdf9...8faa57 )

by joseph
created 2018-09-26 07:35 UTC
itCanBeConfiguredNotToLoadFromTheCache() A

↳ Parent: FixtureLoaderAndHelperTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	31
Code Lines	25
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	25
nc	2
nop	1
dl	0
loc	31
rs	9.52
c	0
b	0
f	0
<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Tests\Large\Entity\Testing\Fixtures;

use Doctrine\Common\Cache\FilesystemCache;
use Doctrine\Common\DataFixtures\Loader;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Interfaces\String\EnumFieldInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits\String\EnumFieldTrait;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Savers\EntitySaverFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\EntityGenerator\TestEntityGeneratorFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\Fixtures\AbstractEntityFixtureLoader;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\Fixtures\FixtureEntitiesModifierInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\Fixtures\FixturesHelper;
use EdmondsCommerce\DoctrineStaticMeta\Schema\Database;
use EdmondsCommerce\DoctrineStaticMeta\Schema\Schema;
use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractLargeTest;
use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractTest;

/**
 * @covers \EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\Fixtures\AbstractEntityFixtureLoader
 * @covers \EdmondsCommerce\DoctrineStaticMeta\Entity\Testing\Fixtures\FixturesHelper
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class FixtureLoaderAndHelperTest extends AbstractLargeTest
{
    public const TEST_PROJECT_ROOT_NAMESPACE = 'Fixtures\\Test';

    public const WORK_DIR = AbstractTest::VAR_PATH .
                            self::TEST_TYPE_LARGE .
                            '/FixturesTest';

    private const ENTITY_WITHOUT_MODIFIER = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Entities\\Person';

    private const ENTITY_WITH_MODIFIER = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Entities\\Attributes\\Address';

    protected static $buildOnce = true;
    /**
     * @var FixturesHelper
     */
    private $helper;

    public function setup(): void
    {
        parent::setUp();
        if (false === self::$built) {
            $this->getTestCodeGenerator()
                 ->copyTo(self::WORK_DIR, self::TEST_PROJECT_ROOT_NAMESPACE);
            $this->getFieldSetter()
                 ->setEntityHasField(
                     self::ENTITY_WITHOUT_MODIFIER,
                     EnumFieldTrait::class
                 );
            self::$built = true;
        }
        $this->setupCopiedWorkDirAndCreateDatabase();
        $cacheDir = $this->copiedWorkDir . '/cache';
        mkdir($cacheDir, 0777, true);
        $this->helper = new FixturesHelper(
            $this->getEntityManager(),
            $this->container->get(Database::class),
            $this->container->get(Schema::class),
            new FilesystemCache($cacheDir)
        );
    }

    /**
     * @test
     * @large
     */
    public function itLoadsAllTheFixturesWithRandomDataByDefault(): array
    {
        $this->helper->setCacheKey(__CLASS__ . '_unmodified');
        $fixture = $this->getUnmodifiedFixture();
        $this->helper->addFixture($fixture);
        $this->helper->createDb();
        $actual      = $this->getEntityManager()
                            ->getRepository($this->getCopiedFqn(self::ENTITY_WITHOUT_MODIFIER))
                            ->findAll();
        $actualCount = count($actual);
        self::assertSame(AbstractEntityFixtureLoader::BULK_AMOUNT_TO_GENERATE, $actualCount);

        return $actual;
    }

    private function getUnmodifiedFixture(): AbstractEntityFixtureLoader
    {
        return $this->getFixture($this->getCopiedFqn(self::ENTITY_WITHOUT_MODIFIER));
    }

    private function getFixture(
        string $entityFqn,
        ?FixtureEntitiesModifierInterface $modifier = null
    ): AbstractEntityFixtureLoader {
        $fixtureFqn = $this->getNamespaceHelper()->getFixtureFqnFromEntityFqn($entityFqn);

        return new $fixtureFqn(
            $this->container->get(TestEntityGeneratorFactory::class),
            $this->container->get(EntitySaverFactory::class),
            $this->container->get(NamespaceHelper::class),
            $modifier
        );
    }

    /**
     * @test
     * @large
     * @depends itLoadsAllTheFixturesWithRandomDataByDefault
     *
     * @param array $loadedFirstTime
     *
     * @return array
     */
    public function itUsesTheCacheTheSecondTime(array $loadedFirstTime): array
    {
        $this->getFileSystem()
             ->mirror(
                 $this->copiedWorkDir .
                 '/../FixtureLoaderAndHelperTest_ItLoadsAllTheFixturesWithRandomDataByDefault_/cache',
                 $this->copiedWorkDir . '/cache'
             );
        $this->helper->setCacheKey(__CLASS__ . '_unmodified');
        $fixture = $this->getUnmodifiedFixture();
        $this->helper->addFixture($fixture);
        $this->helper->createDb();
        self::assertTrue($this->helper->isLoadedFromCache());
        /**
         * @var EntityInterface[] $loadedSecondTime
         */
        $loadedSecondTime = $this->getEntityManager()
                                 ->getRepository($this->getCopiedFqn(self::ENTITY_WITHOUT_MODIFIER))
                                 ->findAll();
        $actualCount      = count($loadedSecondTime);
        $expectedCount    = count($loadedFirstTime);
        self::assertSame($expectedCount, $actualCount);
        foreach ($loadedSecondTime as $key => $actualEntity) {
            $expectedEntity = $loadedFirstTime[$key];
            $actualId       = $actualEntity->getId();
            $expectedId     = $expectedEntity->getId();
            $expectedText   = $expectedEntity->getString();
            $actualText     = $actualEntity->getString();
            $actualText     = $actualEntity->getString();
            self::assertEquals($expectedId, $actualId, 'Cached Entity ID does not match');
            self::assertEquals($expectedText, $actualText, 'Cached Faker data does not match');
        }

        return $loadedSecondTime;
    }

    /**
     * @test
     * @large
     * @depends itUsesTheCacheTheSecondTime
     *
     * @param array $loadedSecondTime
     *
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ReflectionException
     */
    public function itCanBeConfiguredNotToLoadFromTheCache(array $loadedSecondTime): void
    {
        $this->getFileSystem()
             ->mirror(
                 $this->copiedWorkDir .
                 '/../FixtureLoaderAndHelperTest_ItUsesTheCacheTheSecondTime_/cache',
                 $this->copiedWorkDir . '/cache'
             );
        $this->helper->setCacheKey(__CLASS__ . '_unmodified');
        $fixture = $this->getUnmodifiedFixture();
        $this->helper->setLoadFromCache(false);
        $this->helper->addFixture($fixture);
        $this->helper->createDb();
        self::assertFalse($this->helper->isLoadedFromCache());
        /**
         * @var EntityInterface[] $loadedThirdTime
         */
        $loadedThirdTime = $this->getEntityManager()
                                ->getRepository($this->getCopiedFqn(self::ENTITY_WITHOUT_MODIFIER))
                                ->findAll();
        $actualCount     = count($loadedThirdTime);
        $expectedCount   = count($loadedSecondTime);
        self::assertSame($expectedCount, $actualCount);
        foreach ($loadedThirdTime as $key => $actualEntity) {
            $loadedSecondTimeEntity = $loadedSecondTime[$key];
            $actualId               = $actualEntity->getId();
            $secondTimeEntityId     = $loadedSecondTimeEntity->getId();
            $secondTimeText         = $loadedSecondTimeEntity->getString();
            $actualText             = $actualEntity->getString();
            self::assertNotEquals($secondTimeEntityId, $actualId, 'Cached Entity ID matches, this should not happen');
            self::assertNotEquals($secondTimeText, $actualText, 'Cached Faker data matches, this should not happen');
        }
    }

    /**
     * @test
     * @large
     */
    public function itCanTakeAModifierToCustomiseTheFixtures()
    {
        $this->helper->setCacheKey(__CLASS__ . '_modified');
        $fixture = $this->getModifiedFixture();
        $this->helper->addFixture($fixture);
        $this->helper->createDb();
        /**
         * @var EntityInterface[] $actual
         */
        $actual      = $this->getEntityManager()
                            ->getRepository($this->getCopiedFqn(self::ENTITY_WITH_MODIFIER))
                            ->findAll();
        $actualCount = count($actual);
        self::assertSame(AbstractEntityFixtureLoader::BULK_AMOUNT_TO_GENERATE + 1, $actualCount);
        $firstEntity    = $actual[0];
        $expectedString = 'This has been overridden';
        $actualString   = $firstEntity->getString();
        self::assertSame($expectedString, $actualString);
        end($actual);
        $lastEntity     = current($actual);
        $expectedString = 'This has been created';
        $actualString   = $lastEntity->getString();
        self::assertSame($expectedString, $actualString);
    }

    private function getModifiedFixture(): AbstractEntityFixtureLoader
    {
        return $this->getFixture(
            $this->getCopiedFqn(self::ENTITY_WITH_MODIFIER),
            $this->getFixtureModifier()
        );
    }

    private function getFixtureModifier(): FixtureEntitiesModifierInterface
    {
        return new class(
            $this->getCopiedFqn(self::ENTITY_WITH_MODIFIER),
            $this->getEntityFactory()
        )
            implements FixtureEntitiesModifierInterface
        {
            /**
             * @var string
             */
            protected $entityFqn;
            /**
             * @var EntityFactory
             */
            protected $factory;
            /**
             * @var array|EntityInterface[]
             */
            private $entities;

            public function __construct(string $entityFqn, EntityFactory $factory)
            {
                $this->entityFqn = $entityFqn;
                $this->factory   = $factory;
            }

            /**
             * Update the entities array by reference
             *
             * @param array $entities
             */
            public function modifyEntities(array &$entities): void
            {
                $this->entities = &$entities;
                $this->updateFirstEntity();
                $this->addAnotherEntity();
            }

            private function updateFirstEntity(): void
            {
                $this->entities[0]->setString('This has been overridden');
            }

            private function addAnotherEntity(): void
            {
                $entity = $this->factory->create($this->entityFqn);
                $entity->setString('This has been created');
                         setString('This has been created');
                $this->entities[] = $entity;
            }
        };
    }

    /**
     * @test
     * @large
     */
    public function theOrderOfFixtureLoadingCanBeSet(): void
    {
        $loader   = new Loader();
        $fixture1 = $this->getModifiedFixture();
        $loader->addFixture($fixture1);
        $fixture2 = $this->getUnmodifiedFixture();
        $fixture2->setOrder(AbstractEntityFixtureLoader::ORDER_FIRST);
        $loader->addFixture($fixture2);
        $orderedFixtures = $loader->getFixtures();
        self::assertSame($fixture2, current($orderedFixtures));
    }

    /**
     * @test
     * @large
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     * @throws \ReflectionException
     */
    public function fixturesUseTheCorrectFakerDataProviders(): void
    {
        $entityFqn = $this->getCopiedFqn(self::ENTITY_WITHOUT_MODIFIER);

        $this->helper->setCacheKey(__CLASS__ . '_faker');
        $fixture = $this->getUnmodifiedFixture();
        $this->helper->addFixture($fixture);
        $this->helper->createDb();
        $actual = $this->getEntityManager()
                       ->getRepository($entityFqn)
                       ->findAll();
        /**
         * @var EntityInterface $entity
         */
        foreach ($actual as $entity) {
            self::assertContains($entity->getEnum(), EnumFieldInterface::ENUM_OPTIONS);
        }
    }
}

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Push — master ( 75bdf9...8faa57 )

itCanBeConfiguredNotToLoadFromTheCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
