Doctrine\Tests\ORM\Mapping\NamingStrategyTest

Complexity

Total Complexity

18

Size/Duplication

Total Lines	576
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	defaultNaming()	0	3	1
A	dataClassToTableName()	0	77	1
A	testPropertyToColumnName()	0	3	1
A	testJoinTableName()	0	3	1
A	defaultNamingPlural()	0	3	1
A	underscoreNamingLowerPlural()	0	3	1
A	testJoinColumnName()	0	3	1
A	testClassToTableName()	0	3	1
A	testReferenceColumnName()	0	3	1
A	dataJoinColumnName()	0	19	1
A	underscoreNamingLower()	0	3	1
A	dataReferenceColumnName()	0	9	1
B	dataJoinKeyColumnName()	0	93	1
A	underscoreNamingUpper()	0	3	1
A	dataPropertyToColumnName()	0	77	1
B	dataJoinTableName()	0	135	1
A	underscoreNamingUpperPlural()	0	3	1
A	testJoinKeyColumnName()	0	3	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Mapping;

use Doctrine\ORM\Mapping\Factory\DefaultNamingStrategy;
use Doctrine\ORM\Mapping\Factory\NamingStrategy;
use Doctrine\ORM\Mapping\Factory\UnderscoreNamingStrategy;
use Doctrine\Tests\ORM\Mapping\NamingStrategy\JoinColumnClassNamingStrategy;
use Doctrine\Tests\OrmTestCase;
use const CASE_LOWER;
use const CASE_UPPER;

/**
 * @group DDC-559
 */
class NamingStrategyTest extends OrmTestCase
{
    /**
     * @return DefaultNamingStrategy
     */
    private static function defaultNaming()
    {
        return new DefaultNamingStrategy();
    }

    /**
     * @return DefaultNamingStrategy
     */
    private static function defaultNamingPlural()
    {
        return new DefaultNamingStrategy(true);
    }

    /**
     * @return UnderscoreNamingStrategy
     */
    private static function underscoreNamingLower()
    {
        return new UnderscoreNamingStrategy(CASE_LOWER);
    }

    /**
     * @return UnderscoreNamingStrategy
     */
    private static function underscoreNamingUpper()
    {
        return new UnderscoreNamingStrategy(CASE_UPPER);
    }

    /**
     * @return UnderscoreNamingStrategy
     */
    private static function underscoreNamingLowerPlural()
    {
        return new UnderscoreNamingStrategy(CASE_LOWER, true);
    }

    /**
     * @return UnderscoreNamingStrategy
     */
    private static function underscoreNamingUpperPlural()
    {
        return new UnderscoreNamingStrategy(CASE_UPPER, true);
    }

    /**
     * Data Provider for NamingStrategy#classToTableName
     *
     * @return array
     */
    public static function dataClassToTableName()
    {
        return [
            // DefaultNamingStrategy
            [
                self::defaultNaming(),
                'SomeClassName',
                'SomeClassName',
            ],
            [
                self::defaultNaming(),
                'SomeClassName',
                '\SomeClassName',
            ],
            [
                self::defaultNaming(),
                'Name',
                '\Some\Class\Name',
            ],
            // DefaultNamingStrategy plural
            [
                self::defaultNamingPlural(),
                'SomeClassNames',
                'SomeClassName',
            ],
            [
                self::defaultNamingPlural(),
                'SomeClassNames',
                '\SomeClassName',
            ],
            [
                self::defaultNamingPlural(),
                'Names',
                '\Some\Class\Name',
            ],

            // UnderscoreNamingStrategy
            [
                self::underscoreNamingLower(),
                'some_class_name',
                '\Name\Space\SomeClassName',
            ],
            [
                self::underscoreNamingLower(),
                'name',
                '\Some\Class\Name',
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_CLASS_NAME',
                '\Name\Space\SomeClassName',
            ],
            [
                self::underscoreNamingUpper(),
                'NAME',
                '\Some\Class\Name',
            ],
            // UnderscoreNamingStrategy plural
            [
                self::underscoreNamingLowerPlural(),
                'some_class_names',
                '\Name\Space\SomeClassName',
            ],
            [
                self::underscoreNamingLowerPlural(),
                'names',
                '\Some\Class\Name',
            ],
            [
                self::underscoreNamingUpperPlural(),
                'SOME_CLASS_NAMES',
                '\Name\Space\SomeClassName',
            ],
            [
                self::underscoreNamingUpperPlural(),
                'NAMES',
                '\Some\Class\Name',
            ],
        ];
    }

    /**
     * @dataProvider dataClassToTableName
     */
    public function testClassToTableName(NamingStrategy $strategy, $expected, $className) : void
    {
        self::assertEquals($expected, $strategy->classToTableName($className));
    }

    /**
     * Data Provider for NamingStrategy#propertyToColumnName
     *
     * @return array
     */
    public static function dataPropertyToColumnName()
    {
        return [
            // DefaultNamingStrategy
            [
                self::defaultNaming(),
                'someProperty',
                'someProperty',
            ],
            [
                self::defaultNaming(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
            ],
            [
                self::defaultNaming(),
                'some_property',
                'some_property',
            ],
            // DefaultNamingStrategy plural
            [
                self::defaultNamingPlural(),
                'someProperty',
                'someProperty',
            ],
            [
                self::defaultNamingPlural(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
            ],
            [
                self::defaultNamingPlural(),
                'some_property',
                'some_property',
            ],

            // UnderscoreNamingStrategy
            [
                self::underscoreNamingLower(),
                'some_property',
                'someProperty',
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'someProperty',
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'some_property',
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
            ],
            // UnderscoreNamingStrategy plural
            [
                self::underscoreNamingLowerPlural(),
                'some_property',
                'someProperty',
            ],
            [
                self::underscoreNamingUpperPlural(),
                'SOME_PROPERTY',
                'someProperty',
            ],
            [
                self::underscoreNamingUpperPlural(),
                'SOME_PROPERTY',
                'some_property',
            ],
            [
                self::underscoreNamingUpperPlural(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
            ],
        ];
    }

    /**
     * @param string $expected
     * @param string $propertyName
     *
     * @dataProvider dataPropertyToColumnName
     */
    public function testPropertyToColumnName(NamingStrategy $strategy, $expected, $propertyName) : void
    {
        self::assertEquals($expected, $strategy->propertyToColumnName($propertyName));
    }

    /**
     * Data Provider for NamingStrategy#referenceColumnName
     *
     * @return array
     */
    public static function dataReferenceColumnName()
    {
        return [
            // DefaultNamingStrategy
            [self::defaultNaming(), 'id'],

            // UnderscoreNamingStrategy
            [self::underscoreNamingLower(), 'id'],
            [self::underscoreNamingUpper(), 'ID'],
        ];
    }

    /**
     * @param string $expected
     *
     * @dataProvider dataReferenceColumnName
     */
    public function testReferenceColumnName(NamingStrategy $strategy, $expected) : void
    {
        self::assertEquals($expected, $strategy->referenceColumnName());
    }

    /**
     * Data Provider for NamingStrategy#joinColumnName
     *
     * @return array
     */
    public static function dataJoinColumnName()
    {
        return [
            // DefaultNamingStrategy
            [self::defaultNaming(), 'someColumn_id', 'someColumn', null],
            [self::defaultNaming(), 'some_column_id', 'some_column', null],
            // DefaultNamingStrategy plural
            [self::defaultNamingPlural(), 'someColumn_id', 'someColumn', null],
            [self::defaultNamingPlural(), 'some_column_id', 'some_column', null],

            // UnderscoreNamingStrategy
            [self::underscoreNamingLower(), 'some_column_id', 'someColumn', null],
            [self::underscoreNamingUpper(), 'SOME_COLUMN_ID', 'someColumn', null],
            // UnderscoreNamingStrategy plural
            [self::underscoreNamingLowerPlural(), 'some_column_id', 'someColumn', null],
            [self::underscoreNamingUpperPlural(), 'SOME_COLUMN_ID', 'someColumn', null],
            // JoinColumnClassNamingStrategy
            [new JoinColumnClassNamingStrategy(), 'classname_someColumn_id', 'someColumn', 'Some\ClassName'],
            [new JoinColumnClassNamingStrategy(), 'classname_some_column_id', 'some_column', 'ClassName'],
        ];
    }

    /**
     * @param string $expected
     * @param string $propertyName
     *
     * @dataProvider dataJoinColumnName
     */
    public function testJoinColumnName(NamingStrategy $strategy, $expected, $propertyName, $className = null) : void
    {
        self::assertEquals($expected, $strategy->joinColumnName($propertyName, $className));
    }

    /**
     * Data Provider for NamingStrategy#joinTableName
     *
     * @return array
     */
    public static function dataJoinTableName()
    {
        return [
            // DefaultNamingStrategy
            [
                self::defaultNaming(),
                'someclassname_classname',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::defaultNaming(),
                'someclassname_classname',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::defaultNaming(),
                'name_classname',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],
            // DefaultNamingStrategy plural
            [
                self::defaultNamingPlural(),
                'someclassname_classname',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::defaultNamingPlural(),
                'someclassname_classname',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::defaultNamingPlural(),
                'name_classname',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],

            // UnderscoreNamingStrategy
            [
                self::underscoreNamingLower(),
                'some_class_name_class_name',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::underscoreNamingLower(),
                'some_class_name_class_name',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::underscoreNamingLower(),
                'name_class_name',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],

            [
                self::underscoreNamingUpper(),
                'SOME_CLASS_NAME_CLASS_NAME',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_CLASS_NAME_CLASS_NAME',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'NAME_CLASS_NAME',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],
            // UnderscoreNamingStrategy plural
            [
                self::underscoreNamingLowerPlural(),
                'some_class_name_class_name',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::underscoreNamingLowerPlural(),
                'some_class_name_class_name',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::underscoreNamingLowerPlural(),
                'name_class_name',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],

            [
                self::underscoreNamingUpperPlural(),
                'SOME_CLASS_NAME_CLASS_NAME',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::underscoreNamingUpperPlural(),
                'SOME_CLASS_NAME_CLASS_NAME',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::underscoreNamingUpperPlural(),
                'NAME_CLASS_NAME',
                '\Some\Class\Name',
                'ClassName',
                null,
            ],
        ];
    }

    /**
     * @param string $expected
     * @param string $ownerEntity
     * @param string $associatedEntity
     * @param string $propertyName
     *
     * @dataProvider dataJoinTableName
     */
    public function testJoinTableName(NamingStrategy $strategy, $expected, $ownerEntity, $associatedEntity, $propertyName = null) : void
    {
        self::assertEquals($expected, $strategy->joinTableName($ownerEntity, $associatedEntity, $propertyName));
    }

    /**
     * Data Provider for NamingStrategy#joinKeyColumnName
     *
     * @return array
     */
    public static function dataJoinKeyColumnName()
    {
        return [
            // DefaultNamingStrategy
            [
                self::defaultNaming(),
                'someclassname_id',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::defaultNaming(),
                'name_identifier',
                '\Some\Class\Name',
                'identifier',
                null,
            ],
            // DefaultNamingStrategy plural
            [
                self::defaultNamingPlural(),
                'someclassname_id',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::defaultNamingPlural(),
                'name_identifier',
                '\Some\Class\Name',
                'identifier',
                null,
            ],

            // UnderscoreNamingStrategy
            [
                self::underscoreNamingLower(),
                'some_class_name_id',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::underscoreNamingLower(),
                'class_name_identifier',
                '\Some\Class\ClassName',
                'identifier',
                null,
            ],

            [
                self::underscoreNamingUpper(),
                'SOME_CLASS_NAME_ID',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'CLASS_NAME_IDENTIFIER',
                '\Some\Class\ClassName',
                'IDENTIFIER',
                null,
            ],
            // UnderscoreNamingStrategy plural
            [
                self::underscoreNamingLowerPlural(),
                'some_class_name_id',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::underscoreNamingLowerPlural(),
                'class_name_identifier',
                '\Some\Class\ClassName',
                'identifier',
                null,
            ],

            [
                self::underscoreNamingUpperPlural(),
                'SOME_CLASS_NAME_ID',
                'SomeClassName',
                null,
                null,
            ],
            [
                self::underscoreNamingUpperPlural(),
                'CLASS_NAME_IDENTIFIER',
                '\Some\Class\ClassName',
                'IDENTIFIER',
                null,
            ],
        ];
    }

    /**
     * @param string $expected
     * @param string $propertyEntityName
     * @param string $referencedColumnName
     * @param string $propertyName
     *
     * @dataProvider dataJoinKeyColumnName
     */
    public function testJoinKeyColumnName(NamingStrategy $strategy, $expected, $propertyEntityName, $referencedColumnName = null, $propertyName = null) : void
    {
        self::assertEquals($expected, $strategy->joinKeyColumnName($propertyEntityName, $referencedColumnName, $propertyName));

The call to Doctrine\ORM\Mapping\Factory\NamingStrategy::joinKeyColumnName() has too many arguments starting with $propertyName.

    }
}