NamespaceHelperTest::itCanGetTheEntityFactoryFqnFromEntityFqn() - Code Metrics - Inspection of "Entity factory generation" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#126)

by joseph

created 2018-09-05 16:28 UTC

itCanGetTheEntityFactoryFqnFromEntityFqn() A

↳ Parent: NamespaceHelperTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Tests\Large\CodeGeneration;

use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\RelationsGenerator;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\String\BusinessIdentifierCodeFakerData;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\String\CountryCodeFakerData;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits\String\BusinessIdentifierCodeFieldTrait;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits\String\CountryCodeFieldTrait;
use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractTest;

/**
 * Class NamespaceHelperTest
 *
 * @package EdmondsCommerce\DoctrineStaticMeta\Small\CodeGeneration
 * @coversDefaultClass \EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper
 * @covers  \EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper
 * @large
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 */
class NamespaceHelperTest extends AbstractTest
{
    public const WORK_DIR = AbstractTest::VAR_PATH . '/' . self::TEST_TYPE_LARGE . '/NamespaceHelperTest';

    public const TEST_ENTITY_FQN_BASE = self::TEST_PROJECT_ROOT_NAMESPACE .
                                        '\\' .
                                        AbstractGenerator::ENTITIES_FOLDER_NAME;

    public const TEST_ENTITIES = [
        self::TEST_ENTITY_FQN_BASE . '\\Blah\\Foo',
        self::TEST_ENTITY_FQN_BASE . '\\Bar\\Baz',
        self::TEST_ENTITY_FQN_BASE . '\\No\\Relative',
        self::TEST_ENTITY_FQN_BASE . '\\Meh',
        self::TEST_ENTITY_FQN_BASE . '\\Nested\\Something\\Ho\\Hum',
    ];

    public const TEST_ENTITY_POST_CREATED        = self::TEST_ENTITY_FQN_BASE . '\\Meh';
    public const TEST_ENTITY_POST_CREATED_NESTED = self::TEST_ENTITY_FQN_BASE . '\\Nested\\Something\\Ho\\Hum';
    protected static $buildOnce = true;
    /**
     * @var NamespaceHelper
     */
    private static $helper;

    public static function setupBeforeClass()
    {
        parent::setUpBeforeClass();
        self::$helper = new NamespaceHelper();
    }

    public function setup()
    {
        parent::setup();
        if (true === self::$built) {
            return;
        }
        $entityGenerator    = $this->getEntityGenerator();
        $relationsGenerator = $this->getRelationsGenerator();
        foreach (self::TEST_ENTITIES as $fqn) {
            $entityGenerator->generateEntity($fqn);
            $relationsGenerator->generateRelationCodeForEntity($fqn);
        }
        $relationsGenerator->setEntityHasRelationToEntity(
            self::TEST_ENTITIES[0],
            RelationsGenerator::HAS_MANY_TO_MANY,
            self::TEST_ENTITIES[1]
        );
        self::$built = true;
    }

    /**
     * @test
     * @small
     */
    public function getFixtureFqnFromEntityFqn()
    {
        $expected = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Assets\\EntityFixtures\\Blah\\FooFixture';
        $actual   = self::$helper->getFixtureFqnFromEntityFqn(self::TEST_ENTITIES[0]);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::cropSuffix
     */
    public function cropSuffix(): void
    {
        $fqn      = 'FooBar';
        $suffix   = 'Bar';
        $expected = 'Foo';
        $actual   = self::$helper->cropSuffix($fqn, $suffix);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::swapSuffix
     */
    public function swapSuffix(): void
    {
        $fqn           = 'FooBar';
        $currentSuffix = 'Bar';
        $newSuffix     = 'Baz';
        $expected      = 'FooBaz';
        $actual        = self::$helper->swapSuffix($fqn, $currentSuffix, $newSuffix);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::cropSuffix
     */
    public function cropSuffixWhereSuffixNotInThere(): void
    {
        $fqn      = 'FooBar';
        $suffix   = 'Cheese';
        $expected = 'FooBar';
        $actual   = self::$helper->cropSuffix($fqn, $suffix);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::getObjectShortName
     */
    public function getObjectShortName(): void
    {

        $expectedToObjects = [
            'NamespaceHelperTest' => $this,
            'NamespaceHelper'     => self::$helper,
        ];
        $actual            = [];
        foreach ($expectedToObjects as $object) {
            $actual[self::$helper->getObjectShortName($object)] = $object;
        }
        self::assertSame($expectedToObjects, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::getObjectFqn
     */
    public function getObjectFqn(): void
    {

        $expectedToObjects = [
            \get_class($this)         => $this,
            \get_class(self::$helper) => self::$helper,
        ];
        $actual            = [];
        foreach ($expectedToObjects as $object) {
            $actual[self::$helper->getObjectFqn($object)] = $object;
        }
        self::assertSame($expectedToObjects, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::getClassShortName
     */
    public function getClassShortName(): void
    {
        $expectedToFqns = [
            'NamespaceHelperTest' => \get_class($this),
            'Cheese'              => '\\Super\\Cheese',
        ];
        $actual         = [];
        foreach ($expectedToFqns as $fqn) {
            $actual[self::$helper->getClassShortName($fqn)] = $fqn;
        }
        self::assertSame($expectedToFqns, $actual);
    }

    /**
     * @test
     * @large
     * @covers ::getFakerProviderFqnFromFieldTraitReflection
     */
    public function getFakerProviderFqnFromFieldTraitReflection(): void
    {
        $expected = [
            BusinessIdentifierCodeFieldTrait::class => BusinessIdentifierCodeFakerData::class,
            CountryCodeFieldTrait::class            => CountryCodeFakerData::class,
        ];
        $actual   = [];
        foreach (array_keys($expected) as $fieldFqn) {
            $actual[$fieldFqn] = self::$helper->getFakerProviderFqnFromFieldTraitReflection(
                new \ts\Reflection\ReflectionClass($fieldFqn)
            );
        }
        self::assertSame($expected, $actual);
    }

    public function testTidy(): void
    {
        $namespaceToExpected = [
            'Test\\\\Multiple\\\\\\\Separators' => 'Test\\Multiple\\Separators',
            'No\\Changes\\Required'             => 'No\\Changes\\Required',
        ];
        foreach ($namespaceToExpected as $namespace => $expected) {
            self::assertSame($expected, self::$helper->tidy($namespace));
        }
    }

    public function testRoot(): void
    {
        $namespaceToExpected = [
            '\\Test\\\\Multiple\\\\\\\Separators' => 'Test\\Multiple\\Separators',
            'No\\Changes\\Required'               => 'No\\Changes\\Required',
        ];
        foreach ($namespaceToExpected as $namespace => $expected) {
            self::assertSame($expected, self::$helper->root($namespace));
        }
    }

    /**
     * @test
     * @large
     */
    public function testCalculateProjectNamespaceRootFromEntitFqn(): void
    {
        $entity1Fqn = self::TEST_ENTITIES[0];

        $expected = self::TEST_PROJECT_ROOT_NAMESPACE;
        $actual   = self::$helper->getProjectNamespaceRootFromEntityFqn($entity1Fqn);
        self::assertSame($expected, $actual);

        $entityFqnWithEntitiesInProjectName = self::TEST_ENTITIES[0];
        $expected                           = self::TEST_PROJECT_ROOT_NAMESPACE;
        $actual                             = self::$helper->getProjectNamespaceRootFromEntityFqn(
            $entityFqnWithEntitiesInProjectName
        );
        self::assertSame($expected, $actual);
    }

    /**
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     */
    public function testParseFullyQualifiedName(): void
    {
        $entity1Fqn           = self::TEST_ENTITIES[0];
        $srcOrTestSubFolder   = 'src';
        $projectRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE;
        $expected             = [
            'Foo',
            $projectRootNamespace . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME . '\\Blah',
            [
                'src',
                'Entities',
                'Blah',
            ],
        ];
        $actual               = self::$helper->parseFullyQualifiedName(
            $entity1Fqn,
            $srcOrTestSubFolder,
            $projectRootNamespace
        );
        self::assertSame($expected, $actual);

        $srcOrTestSubFolder   = 'src';
        $projectRootNamespace = '\\' . self::TEST_PROJECT_ROOT_NAMESPACE;
        $expected             = [
            'Foo',
            ltrim($projectRootNamespace . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME . '\\Blah', '\\'),
            [
                'src',
                'Entities',
                'Blah',
            ],
        ];
        $actual               = self::$helper->parseFullyQualifiedName(
            self::TEST_ENTITIES[0],
            $srcOrTestSubFolder,
            $projectRootNamespace
        );
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testCalculcateOwnedHasName(): void
    {
        $hasType              = RelationsGenerator::HAS_MANY_TO_MANY;
        $ownedEntityFqn       = self::TEST_ENTITIES[0];
        $expected             = 'BlahFoos';
        $srcOrTestSubFolder   = 'src';
        $projectRootNamespace = '\\' . self::TEST_PROJECT_ROOT_NAMESPACE;

        $actual = self::$helper->getOwnedHasName(
            $hasType,
            $ownedEntityFqn,
            $srcOrTestSubFolder,
            $projectRootNamespace
        );

        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetEntitySubNamespace(): void
    {
        $entityFqn = self::TEST_ENTITIES[0];
        $expected  = 'Blah\\Foo';
        $actual    = self::$helper->getEntitySubNamespace($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = '\\My\\Test\\Project\\Entities\\No\\Relatives';
        $expected  = 'No\\Relatives';
        $actual    = self::$helper->getEntitySubNamespace($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = '\\My\\Test\\Project\\Entities\\Person';
        $expected  = 'Person';
        $actual    = self::$helper->getEntitySubNamespace($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
        $expected  = 'Person';
        $actual    = self::$helper->getEntitySubNamespace($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetEntitySubFilePath(): void
    {
        $entityFqn = '\\My\\Test\\Project\\Entities\\Person';
        $expected  = '/Person.php';
        $actual    = self::$helper->getEntityFileSubPath($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
        $expected  = '/Person.php';
        $actual    = self::$helper->getEntityFileSubPath($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetEntitySubPath(): void
    {
        $entityFqn = self::TEST_ENTITIES[0];
        $expected  = '/Blah/Foo';
        $actual    = self::$helper->getEntitySubPath($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
        $expected  = '/Person';
        $actual    = self::$helper->getEntitySubPath($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetInterfacesNamespaceForEntity(): void
    {
        $entityFqn                    = self::TEST_ENTITIES[0];
        $entityRelationsRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE
                                        . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE;
        $expected                     = $entityRelationsRootNamespace . '\\Blah\\Foo\\Interfaces';
        $actual                       = self::$helper->getInterfacesNamespaceForEntity($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetTraitsNamespaceForEntity(): void
    {
        $entityFqn                    = self::TEST_ENTITIES[0];
        $entityRelationsRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE
                                        . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE;
        $expected                     = $entityRelationsRootNamespace . '\\Blah\\Foo\\Traits';
        $actual                       = self::$helper->getTraitsNamespaceForEntity($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @throws \ReflectionException
     */
    public function testGetEntityNamespaceRootFromEntityReflection(): void
    {

        $entityReflection = new  \ts\Reflection\ReflectionClass(self::TEST_ENTITIES[0]);
        $expected         = self::TEST_PROJECT_ROOT_NAMESPACE . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME;
        $actual           = self::$helper->getEntityNamespaceRootFromEntityReflection($entityReflection);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testGetHasPluralInterfaceFqnForEntity(): void
    {
        $entityFqn = self::TEST_ENTITY_POST_CREATED;
        $expected  = self::TEST_PROJECT_ROOT_NAMESPACE
                     . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
                     . '\\Meh\\Interfaces\\HasMehsInterface';
        $actual    = self::$helper->getHasPluralInterfaceFqnForEntity($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = self::TEST_ENTITY_POST_CREATED_NESTED;
        $expected  = self::TEST_PROJECT_ROOT_NAMESPACE
                     . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
                     . '\\Nested\\Something\\Ho\\Hum\\Interfaces\\HasNestedSomethingHoHumsInterface';
        $actual    = self::$helper->getHasPluralInterfaceFqnForEntity($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testgetHasSingularInterfaceFqnForEntity(): void
    {
        $entityFqn = self::TEST_ENTITY_POST_CREATED;
        $expected  = self::TEST_PROJECT_ROOT_NAMESPACE
                     . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
                     . '\\Meh\\Interfaces\\HasMehInterface';
        $actual    = self::$helper->getHasSingularInterfaceFqnForEntity($entityFqn);
        self::assertSame($expected, $actual);

        $entityFqn = self::TEST_ENTITY_POST_CREATED_NESTED;
        $expected  = self::TEST_PROJECT_ROOT_NAMESPACE
                     . AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
                     . '\\Nested\\Something\\Ho\\Hum\\Interfaces\\HasNestedSomethingHoHumInterface';
        $actual    = self::$helper->getHasSingularInterfaceFqnForEntity($entityFqn);
        self::assertSame($expected, $actual);
    }

    /**
     * @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
     */
    public function testGetProjectRootNamespaceFromComposerJson(): void
    {
        $expected = 'EdmondsCommerce\\DoctrineStaticMeta';
        $actual   = self::$helper->getProjectRootNamespaceFromComposerJson();
        self::assertSame($expected, $actual);
    }

    /**
     * @test
     * @large
     */
    public function testStripPrefixFromHasType(): void
    {
        $expected = [
            'OwningOneToOne'          => 'OwningOneToOne',
            'InverseOneToOne'         => 'InverseOneToOne',
            'UnidirectionalOneToOne'  => 'UnidirectionalOneToOne',
            'OneToMany'               => 'OneToMany',
            'UnidirectionalOneToMany' => 'UnidirectionalOneToMany',
            'ManyToOne'               => 'ManyToOne',
            'UnidirectionalManyToOne' => 'UnidirectionalManyToOne',
            'OwningManyToMany'        => 'OwningManyToMany',
            'InverseManyToMany'       => 'InverseManyToMany',
        ];
        $actual   = [];
        foreach (RelationsGenerator::HAS_TYPES as $hasType) {
            $actual[$hasType] = self::$helper->stripPrefixFromHasType($hasType);
        }
        self::assertSame($expected, $actual);
        foreach ($actual as $hasType => $stripped) {
            $ownedHasName    = self::$helper->getOwnedHasName(
                $hasType,
                "\\TemplateNamespace\\Entities\\TemplateEntity",
                'src',
                '\\TemplateNamespace'
            );
            $filePath        = realpath(AbstractGenerator::TEMPLATE_PATH)
                               . '/src/Entity/Relations/TemplateEntity/Traits/Has'
                               . $ownedHasName . '/Has' . $ownedHasName . $stripped . '.php';
            $longestExisting = '';
            foreach (explode('/', $filePath) as $part) {
                $maybeLongestExisting = $longestExisting . '/' . $part;
                if (is_file($maybeLongestExisting) || is_dir($maybeLongestExisting)) {
                    $longestExisting = $maybeLongestExisting;
                    continue;
                }
                break;
            }
            $longestExisting = substr($longestExisting, 1);
            self::assertFileExists($filePath, "\n$filePath\nexists up to:\n$longestExisting\n");
        }
    }

    /**
     * @test
     * @large
     */
    public function testGetOwningTraitFqn(): void
    {
        $traitBase = '\\TemplateNamespace\\Entity\Relations\\TemplateEntity\\Traits';
        $expected  = [
            'OwningOneToOne'          => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityOwningOneToOne',
            'InverseOneToOne'         => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityInverseOneToOne',
            'UnidirectionalOneToOne'  => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityUnidirectionalOneToOne',
            'OneToMany'               => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesOneToMany',
            'UnidirectionalOneToMany' => $traitBase .
                                         '\\HasTemplateEntities\\HasTemplateEntitiesUnidirectionalOneToMany',
            'ManyToOne'               => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityManyToOne',
            'UnidirectionalManyToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityUnidirectionalManyToOne',
            'OwningManyToMany'        => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesOwningManyToMany',
            'InverseManyToMany'       => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesInverseManyToMany',
        ];
        $actual    = [];
        foreach (RelationsGenerator::HAS_TYPES as $hasType) {
            $actual[$hasType] = self::$helper->getOwningTraitFqn(
                $hasType,
                "\\TemplateNamespace\\Entities\\TemplateEntity",
                "\\TemplateNamespace"
            );
        }
        self::assertSame(
            $expected,
            $actual,
            "\nExpected:\n" . var_export($actual, true)
            . "\nActual:\n" . var_export($actual, true) . "\n"
        );
    }

    /**
     * @test
     * @large
     */
    public function testGetOwningInterfaceFqn(): void
    {
        $intBase  = '\\TemplateNamespace\\Entity\Relations\\TemplateEntity\\Interfaces';
        $expected = [
            'OwningOneToOne'          => $intBase . '\\HasTemplateEntityInterface',
            'InverseOneToOne'         => $intBase . '\\HasTemplateEntityInterface',
            'UnidirectionalOneToOne'  => $intBase . '\\HasTemplateEntityInterface',
            'OneToMany'               => $intBase . '\\HasTemplateEntitiesInterface',
            'UnidirectionalOneToMany' => $intBase . '\\HasTemplateEntitiesInterface',
            'ManyToOne'               => $intBase . '\\HasTemplateEntityInterface',
            'UnidirectionalManyToOne' => $intBase . '\\HasTemplateEntityInterface',
            'OwningManyToMany'        => $intBase . '\\HasTemplateEntitiesInterface',
            'InverseManyToMany'       => $intBase . '\\HasTemplateEntitiesInterface',
        ];
        $actual   = [];
        foreach (RelationsGenerator::HAS_TYPES as $hasType) {
            $actual[$hasType] = self::$helper->getOwningInterfaceFqn(
                $hasType,
                "\\TemplateNamespace\\Entities\\TemplateEntity",
                "\\TemplateNamespace"
            );
        }
        self::assertSame(
            $expected,
            $actual,
            "\nExpected:\n" . var_export($actual, true)
            . "\nActual:\n" . var_export($actual, true) . "\n"
        );
    }

    /**
     * @test
     * @large
     * @covers ::getFactoryFqnFromEntityFqn
     */
    public function itCanGetTheEntityFactoryFqnFromEntityFqn(): void
    {
        $expected = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Entity\\Factories\\Blah\\FooFactory';
        $actual   = self::$helper->getFactoryFqnFromEntityFqn(self::TEST_ENTITIES[0]);
        self::assertSame($expected, $actual);
    }
}


1			<?php declare(strict_types=1);
2
3			namespace EdmondsCommerce\DoctrineStaticMeta\Tests\Large\CodeGeneration;
4
5			use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
6			use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\RelationsGenerator;
7			use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
8			use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\String\BusinessIdentifierCodeFakerData;
9			use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\FakerData\String\CountryCodeFakerData;
10			use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits\String\BusinessIdentifierCodeFieldTrait;
11			use EdmondsCommerce\DoctrineStaticMeta\Entity\Fields\Traits\String\CountryCodeFieldTrait;
12			use EdmondsCommerce\DoctrineStaticMeta\Tests\Assets\AbstractTest;
13
14			/**
15			* Class NamespaceHelperTest
16			*
17			* @package EdmondsCommerce\DoctrineStaticMeta\Small\CodeGeneration
18			* @coversDefaultClass \EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper
19			* @covers \EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper
20			* @large
21			* @SuppressWarnings(PHPMD.TooManyPublicMethods)
22			*/
23			class NamespaceHelperTest extends AbstractTest
24			{
25			public const WORK_DIR = AbstractTest::VAR_PATH . '/' . self::TEST_TYPE_LARGE . '/NamespaceHelperTest';
26
27			public const TEST_ENTITY_FQN_BASE = self::TEST_PROJECT_ROOT_NAMESPACE .
28			'\\' .
29			AbstractGenerator::ENTITIES_FOLDER_NAME;
30
31			public const TEST_ENTITIES = [
32			self::TEST_ENTITY_FQN_BASE . '\\Blah\\Foo',
33			self::TEST_ENTITY_FQN_BASE . '\\Bar\\Baz',
34			self::TEST_ENTITY_FQN_BASE . '\\No\\Relative',
35			self::TEST_ENTITY_FQN_BASE . '\\Meh',
36			self::TEST_ENTITY_FQN_BASE . '\\Nested\\Something\\Ho\\Hum',
37			];
38
39			public const TEST_ENTITY_POST_CREATED = self::TEST_ENTITY_FQN_BASE . '\\Meh';
40			public const TEST_ENTITY_POST_CREATED_NESTED = self::TEST_ENTITY_FQN_BASE . '\\Nested\\Something\\Ho\\Hum';
41			protected static $buildOnce = true;
42			/**
43			* @var NamespaceHelper
44			*/
45			private static $helper;
46
47			public static function setupBeforeClass()
48			{
49			parent::setUpBeforeClass();
50			self::$helper = new NamespaceHelper();
51			}
52
53			public function setup()
54			{
55			parent::setup();
56			if (true === self::$built) {
57			return;
58			}
59			$entityGenerator = $this->getEntityGenerator();
60			$relationsGenerator = $this->getRelationsGenerator();
61			foreach (self::TEST_ENTITIES as $fqn) {
62			$entityGenerator->generateEntity($fqn);
63			$relationsGenerator->generateRelationCodeForEntity($fqn);
64			}
65			$relationsGenerator->setEntityHasRelationToEntity(
66			self::TEST_ENTITIES[0],
67			RelationsGenerator::HAS_MANY_TO_MANY,
68			self::TEST_ENTITIES[1]
69			);
70			self::$built = true;
71			}
72
73			/**
74			* @test
75			* @small
76			*/
77			public function getFixtureFqnFromEntityFqn()
78			{
79			$expected = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Assets\\EntityFixtures\\Blah\\FooFixture';
80			$actual = self::$helper->getFixtureFqnFromEntityFqn(self::TEST_ENTITIES[0]);
81			self::assertSame($expected, $actual);
82			}
83
84			/**
85			* @test
86			* @large
87			* @covers ::cropSuffix
88			*/
89			public function cropSuffix(): void
90			{
91			$fqn = 'FooBar';
92			$suffix = 'Bar';
93			$expected = 'Foo';
94			$actual = self::$helper->cropSuffix($fqn, $suffix);
95			self::assertSame($expected, $actual);
96			}
97
98			/**
99			* @test
100			* @large
101			* @covers ::swapSuffix
102			*/
103			public function swapSuffix(): void
104			{
105			$fqn = 'FooBar';
106			$currentSuffix = 'Bar';
107			$newSuffix = 'Baz';
108			$expected = 'FooBaz';
109			$actual = self::$helper->swapSuffix($fqn, $currentSuffix, $newSuffix);
110			self::assertSame($expected, $actual);
111			}
112
113			/**
114			* @test
115			* @large
116			* @covers ::cropSuffix
117			*/
118			public function cropSuffixWhereSuffixNotInThere(): void
119			{
120			$fqn = 'FooBar';
121			$suffix = 'Cheese';
122			$expected = 'FooBar';
123			$actual = self::$helper->cropSuffix($fqn, $suffix);
124			self::assertSame($expected, $actual);
125			}
126
127			/**
128			* @test
129			* @large
130			* @covers ::getObjectShortName
131			*/
132			public function getObjectShortName(): void
133			{
134
135			$expectedToObjects = [
136			'NamespaceHelperTest' => $this,
137			'NamespaceHelper' => self::$helper,
138			];
139			$actual = [];
140			foreach ($expectedToObjects as $object) {
141			$actual[self::$helper->getObjectShortName($object)] = $object;
142			}
143			self::assertSame($expectedToObjects, $actual);
144			}
145
146			/**
147			* @test
148			* @large
149			* @covers ::getObjectFqn
150			*/
151			public function getObjectFqn(): void
152			{
153
154			$expectedToObjects = [
155			\get_class($this) => $this,
156			\get_class(self::$helper) => self::$helper,
157			];
158			$actual = [];
159			foreach ($expectedToObjects as $object) {
160			$actual[self::$helper->getObjectFqn($object)] = $object;
161			}
162			self::assertSame($expectedToObjects, $actual);
163			}
164
165			/**
166			* @test
167			* @large
168			* @covers ::getClassShortName
169			*/
170			public function getClassShortName(): void
171			{
172			$expectedToFqns = [
173			'NamespaceHelperTest' => \get_class($this),
174			'Cheese' => '\\Super\\Cheese',
175			];
176			$actual = [];
177			foreach ($expectedToFqns as $fqn) {
178			$actual[self::$helper->getClassShortName($fqn)] = $fqn;
179			}
180			self::assertSame($expectedToFqns, $actual);
181			}
182
183			/**
184			* @test
185			* @large
186			* @covers ::getFakerProviderFqnFromFieldTraitReflection
187			*/
188			public function getFakerProviderFqnFromFieldTraitReflection(): void
189			{
190			$expected = [
191			BusinessIdentifierCodeFieldTrait::class => BusinessIdentifierCodeFakerData::class,
192			CountryCodeFieldTrait::class => CountryCodeFakerData::class,
193			];
194			$actual = [];
195			foreach (array_keys($expected) as $fieldFqn) {
196			$actual[$fieldFqn] = self::$helper->getFakerProviderFqnFromFieldTraitReflection(
197			new \ts\Reflection\ReflectionClass($fieldFqn)
198			);
199			}
200			self::assertSame($expected, $actual);
201			}
202
203			public function testTidy(): void
204			{
205			$namespaceToExpected = [
206			'Test\\\\Multiple\\\\\\\Separators' => 'Test\\Multiple\\Separators',
207			'No\\Changes\\Required' => 'No\\Changes\\Required',
208			];
209			foreach ($namespaceToExpected as $namespace => $expected) {
210			self::assertSame($expected, self::$helper->tidy($namespace));
211			}
212			}
213
214			public function testRoot(): void
215			{
216			$namespaceToExpected = [
217			'\\Test\\\\Multiple\\\\\\\Separators' => 'Test\\Multiple\\Separators',
218			'No\\Changes\\Required' => 'No\\Changes\\Required',
219			];
220			foreach ($namespaceToExpected as $namespace => $expected) {
221			self::assertSame($expected, self::$helper->root($namespace));
222			}
223			}
224
225			/**
226			* @test
227			* @large
228			*/
229			public function testCalculateProjectNamespaceRootFromEntitFqn(): void
230			{
231			$entity1Fqn = self::TEST_ENTITIES[0];
232
233			$expected = self::TEST_PROJECT_ROOT_NAMESPACE;
234			$actual = self::$helper->getProjectNamespaceRootFromEntityFqn($entity1Fqn);
235			self::assertSame($expected, $actual);
236
237			$entityFqnWithEntitiesInProjectName = self::TEST_ENTITIES[0];
238			$expected = self::TEST_PROJECT_ROOT_NAMESPACE;
239			$actual = self::$helper->getProjectNamespaceRootFromEntityFqn(
240			$entityFqnWithEntitiesInProjectName
241			);
242			self::assertSame($expected, $actual);
243			}
244
245			/**
246			* @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
247			*/
248			public function testParseFullyQualifiedName(): void
249			{
250			$entity1Fqn = self::TEST_ENTITIES[0];
251			$srcOrTestSubFolder = 'src';
252			$projectRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE;
253			$expected = [
254			'Foo',
255			$projectRootNamespace . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME . '\\Blah',
256			[
257			'src',
258			'Entities',
259			'Blah',
260			],
261			];
262			$actual = self::$helper->parseFullyQualifiedName(
263			$entity1Fqn,
264			$srcOrTestSubFolder,
265			$projectRootNamespace
266			);
267			self::assertSame($expected, $actual);
268
269			$srcOrTestSubFolder = 'src';
270			$projectRootNamespace = '\\' . self::TEST_PROJECT_ROOT_NAMESPACE;
271			$expected = [
272			'Foo',
273			ltrim($projectRootNamespace . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME . '\\Blah', '\\'),
274			[
275			'src',
276			'Entities',
277			'Blah',
278			],
279			];
280			$actual = self::$helper->parseFullyQualifiedName(
281			self::TEST_ENTITIES[0],
282			$srcOrTestSubFolder,
283			$projectRootNamespace
284			);
285			self::assertSame($expected, $actual);
286			}
287
288			/**
289			* @test
290			* @large
291			*/
292			public function testCalculcateOwnedHasName(): void
293			{
294			$hasType = RelationsGenerator::HAS_MANY_TO_MANY;
295			$ownedEntityFqn = self::TEST_ENTITIES[0];
296			$expected = 'BlahFoos';
297			$srcOrTestSubFolder = 'src';
298			$projectRootNamespace = '\\' . self::TEST_PROJECT_ROOT_NAMESPACE;
299
300			$actual = self::$helper->getOwnedHasName(
301			$hasType,
302			$ownedEntityFqn,
303			$srcOrTestSubFolder,
304			$projectRootNamespace
305			);
306
307			self::assertSame($expected, $actual);
308			}
309
310			/**
311			* @test
312			* @large
313			*/
314			public function testGetEntitySubNamespace(): void
315			{
316			$entityFqn = self::TEST_ENTITIES[0];
317			$expected = 'Blah\\Foo';
318			$actual = self::$helper->getEntitySubNamespace($entityFqn);
319			self::assertSame($expected, $actual);
320
321			$entityFqn = '\\My\\Test\\Project\\Entities\\No\\Relatives';
322			$expected = 'No\\Relatives';
323			$actual = self::$helper->getEntitySubNamespace($entityFqn);
324			self::assertSame($expected, $actual);
325
326			$entityFqn = '\\My\\Test\\Project\\Entities\\Person';
327			$expected = 'Person';
328			$actual = self::$helper->getEntitySubNamespace($entityFqn);
329			self::assertSame($expected, $actual);
330
331			$entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
332			$expected = 'Person';
333			$actual = self::$helper->getEntitySubNamespace($entityFqn);
334			self::assertSame($expected, $actual);
335			}
336
337			/**
338			* @test
339			* @large
340			*/
341			public function testGetEntitySubFilePath(): void
342			{
343			$entityFqn = '\\My\\Test\\Project\\Entities\\Person';
344			$expected = '/Person.php';
345			$actual = self::$helper->getEntityFileSubPath($entityFqn);
346			self::assertSame($expected, $actual);
347
348			$entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
349			$expected = '/Person.php';
350			$actual = self::$helper->getEntityFileSubPath($entityFqn);
351			self::assertSame($expected, $actual);
352			}
353
354			/**
355			* @test
356			* @large
357			*/
358			public function testGetEntitySubPath(): void
359			{
360			$entityFqn = self::TEST_ENTITIES[0];
361			$expected = '/Blah/Foo';
362			$actual = self::$helper->getEntitySubPath($entityFqn);
363			self::assertSame($expected, $actual);
364
365			$entityFqn = '\\My\\Test\\EntitiesProject\\Entities\\Person';
366			$expected = '/Person';
367			$actual = self::$helper->getEntitySubPath($entityFqn);
368			self::assertSame($expected, $actual);
369			}
370
371			/**
372			* @test
373			* @large
374			*/
375			public function testGetInterfacesNamespaceForEntity(): void
376			{
377			$entityFqn = self::TEST_ENTITIES[0];
378			$entityRelationsRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE
379			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE;
380			$expected = $entityRelationsRootNamespace . '\\Blah\\Foo\\Interfaces';
381			$actual = self::$helper->getInterfacesNamespaceForEntity($entityFqn);
382			self::assertSame($expected, $actual);
383			}
384
385			/**
386			* @test
387			* @large
388			*/
389			public function testGetTraitsNamespaceForEntity(): void
390			{
391			$entityFqn = self::TEST_ENTITIES[0];
392			$entityRelationsRootNamespace = self::TEST_PROJECT_ROOT_NAMESPACE
393			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE;
394			$expected = $entityRelationsRootNamespace . '\\Blah\\Foo\\Traits';
395			$actual = self::$helper->getTraitsNamespaceForEntity($entityFqn);
396			self::assertSame($expected, $actual);
397			}
398
399			/**
400			* @throws \ReflectionException
401			*/
402			public function testGetEntityNamespaceRootFromEntityReflection(): void
403			{
404
405			$entityReflection = new \ts\Reflection\ReflectionClass(self::TEST_ENTITIES[0]);
406			$expected = self::TEST_PROJECT_ROOT_NAMESPACE . '\\' . AbstractGenerator::ENTITIES_FOLDER_NAME;
407			$actual = self::$helper->getEntityNamespaceRootFromEntityReflection($entityReflection);
408			self::assertSame($expected, $actual);
409			}
410
411			/**
412			* @test
413			* @large
414			*/
415			public function testGetHasPluralInterfaceFqnForEntity(): void
416			{
417			$entityFqn = self::TEST_ENTITY_POST_CREATED;
418			$expected = self::TEST_PROJECT_ROOT_NAMESPACE
419			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
420			. '\\Meh\\Interfaces\\HasMehsInterface';
421			$actual = self::$helper->getHasPluralInterfaceFqnForEntity($entityFqn);
422			self::assertSame($expected, $actual);
423
424			$entityFqn = self::TEST_ENTITY_POST_CREATED_NESTED;
425			$expected = self::TEST_PROJECT_ROOT_NAMESPACE
426			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
427			. '\\Nested\\Something\\Ho\\Hum\\Interfaces\\HasNestedSomethingHoHumsInterface';
428			$actual = self::$helper->getHasPluralInterfaceFqnForEntity($entityFqn);
429			self::assertSame($expected, $actual);
430			}
431
432			/**
433			* @test
434			* @large
435			*/
436			public function testgetHasSingularInterfaceFqnForEntity(): void
437			{
438			$entityFqn = self::TEST_ENTITY_POST_CREATED;
439			$expected = self::TEST_PROJECT_ROOT_NAMESPACE
440			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
441			. '\\Meh\\Interfaces\\HasMehInterface';
442			$actual = self::$helper->getHasSingularInterfaceFqnForEntity($entityFqn);
443			self::assertSame($expected, $actual);
444
445			$entityFqn = self::TEST_ENTITY_POST_CREATED_NESTED;
446			$expected = self::TEST_PROJECT_ROOT_NAMESPACE
447			. AbstractGenerator::ENTITY_RELATIONS_NAMESPACE
448			. '\\Nested\\Something\\Ho\\Hum\\Interfaces\\HasNestedSomethingHoHumInterface';
449			$actual = self::$helper->getHasSingularInterfaceFqnForEntity($entityFqn);
450			self::assertSame($expected, $actual);
451			}
452
453			/**
454			* @throws \EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException
455			*/
456			public function testGetProjectRootNamespaceFromComposerJson(): void
457			{
458			$expected = 'EdmondsCommerce\\DoctrineStaticMeta';
459			$actual = self::$helper->getProjectRootNamespaceFromComposerJson();
460			self::assertSame($expected, $actual);
461			}
462
463			/**
464			* @test
465			* @large
466			*/
467			public function testStripPrefixFromHasType(): void
468			{
469			$expected = [
470			'OwningOneToOne' => 'OwningOneToOne',
471			'InverseOneToOne' => 'InverseOneToOne',
472			'UnidirectionalOneToOne' => 'UnidirectionalOneToOne',
473			'OneToMany' => 'OneToMany',
474			'UnidirectionalOneToMany' => 'UnidirectionalOneToMany',
475			'ManyToOne' => 'ManyToOne',
476			'UnidirectionalManyToOne' => 'UnidirectionalManyToOne',
477			'OwningManyToMany' => 'OwningManyToMany',
478			'InverseManyToMany' => 'InverseManyToMany',
479			];
480			$actual = [];
481			foreach (RelationsGenerator::HAS_TYPES as $hasType) {
482			$actual[$hasType] = self::$helper->stripPrefixFromHasType($hasType);
483			}
484			self::assertSame($expected, $actual);
485			foreach ($actual as $hasType => $stripped) {
486			$ownedHasName = self::$helper->getOwnedHasName(
487			$hasType,
488			"\\TemplateNamespace\\Entities\\TemplateEntity",
489			'src',
490			'\\TemplateNamespace'
491			);
492			$filePath = realpath(AbstractGenerator::TEMPLATE_PATH)
493			. '/src/Entity/Relations/TemplateEntity/Traits/Has'
494			. $ownedHasName . '/Has' . $ownedHasName . $stripped . '.php';
495			$longestExisting = '';
496			foreach (explode('/', $filePath) as $part) {
497			$maybeLongestExisting = $longestExisting . '/' . $part;
498			if (is_file($maybeLongestExisting) \|\| is_dir($maybeLongestExisting)) {
499			$longestExisting = $maybeLongestExisting;
500			continue;
501			}
502			break;
503			}
504			$longestExisting = substr($longestExisting, 1);
505			self::assertFileExists($filePath, "\n$filePath\nexists up to:\n$longestExisting\n");
506			}
507			}
508
509			/**
510			* @test
511			* @large
512			*/
513			public function testGetOwningTraitFqn(): void
514			{
515			$traitBase = '\\TemplateNamespace\\Entity\Relations\\TemplateEntity\\Traits';
516			$expected = [
517			'OwningOneToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityOwningOneToOne',
518			'InverseOneToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityInverseOneToOne',
519			'UnidirectionalOneToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityUnidirectionalOneToOne',
520			'OneToMany' => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesOneToMany',
521			'UnidirectionalOneToMany' => $traitBase .
522			'\\HasTemplateEntities\\HasTemplateEntitiesUnidirectionalOneToMany',
523			'ManyToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityManyToOne',
524			'UnidirectionalManyToOne' => $traitBase . '\\HasTemplateEntity\\HasTemplateEntityUnidirectionalManyToOne',
525			'OwningManyToMany' => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesOwningManyToMany',
526			'InverseManyToMany' => $traitBase . '\\HasTemplateEntities\\HasTemplateEntitiesInverseManyToMany',
527			];
528			$actual = [];
529			foreach (RelationsGenerator::HAS_TYPES as $hasType) {
530			$actual[$hasType] = self::$helper->getOwningTraitFqn(
531			$hasType,
532			"\\TemplateNamespace\\Entities\\TemplateEntity",
533			"\\TemplateNamespace"
534			);
535			}
536			self::assertSame(
537			$expected,
538			$actual,
539			"\nExpected:\n" . var_export($actual, true)
540			. "\nActual:\n" . var_export($actual, true) . "\n"
541			);
542			}
543
544			/**
545			* @test
546			* @large
547			*/
548			public function testGetOwningInterfaceFqn(): void
549			{
550			$intBase = '\\TemplateNamespace\\Entity\Relations\\TemplateEntity\\Interfaces';
551			$expected = [
552			'OwningOneToOne' => $intBase . '\\HasTemplateEntityInterface',
553			'InverseOneToOne' => $intBase . '\\HasTemplateEntityInterface',
554			'UnidirectionalOneToOne' => $intBase . '\\HasTemplateEntityInterface',
555			'OneToMany' => $intBase . '\\HasTemplateEntitiesInterface',
556			'UnidirectionalOneToMany' => $intBase . '\\HasTemplateEntitiesInterface',
557			'ManyToOne' => $intBase . '\\HasTemplateEntityInterface',
558			'UnidirectionalManyToOne' => $intBase . '\\HasTemplateEntityInterface',
559			'OwningManyToMany' => $intBase . '\\HasTemplateEntitiesInterface',
560			'InverseManyToMany' => $intBase . '\\HasTemplateEntitiesInterface',
561			];
562			$actual = [];
563			foreach (RelationsGenerator::HAS_TYPES as $hasType) {
564			$actual[$hasType] = self::$helper->getOwningInterfaceFqn(
565			$hasType,
566			"\\TemplateNamespace\\Entities\\TemplateEntity",
567			"\\TemplateNamespace"
568			);
569			}
570			self::assertSame(
571			$expected,
572			$actual,
573			"\nExpected:\n" . var_export($actual, true)
574			. "\nActual:\n" . var_export($actual, true) . "\n"
575			);
576			}
577
578			/**
579			* @test
580			* @large
581			* @covers ::getFactoryFqnFromEntityFqn
582			*/
583			public function itCanGetTheEntityFactoryFqnFromEntityFqn(): void
584			{
585			$expected = self::TEST_PROJECT_ROOT_NAMESPACE . '\\Entity\\Factories\\Blah\\FooFactory';
586			$actual = self::$helper->getFactoryFqnFromEntityFqn(self::TEST_ENTITIES[0]);
587			self::assertSame($expected, $actual);
588			}
589			}
590

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#126)

itCanGetTheEntityFactoryFqnFromEntityFqn() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like