vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Mapping/NamingStrategyTest.php

   1 <?php
   2
   3 namespace Doctrine\Tests\ORM\Mapping;
   4
   5 use Doctrine\ORM\Mapping\UnderscoreNamingStrategy;
   6 use Doctrine\ORM\Mapping\DefaultNamingStrategy;
   7 use Doctrine\ORM\Mapping\NamingStrategy;
   8
   9 require_once __DIR__ . '/../../TestInit.php';
  10
  11 /**
  12  * @group DDC-559
  13  */
  14 class NamingStrategyTest extends \Doctrine\Tests\OrmTestCase
  15 {
  16     /**
  17      * @return DefaultNamingStrategy
  18      */
  19     static private function defaultNaming()
  20     {
  21         return new DefaultNamingStrategy();
  22     }
  23
  24     /**
  25      * @return UnderscoreNamingStrategy
  26      */
  27     static private function underscoreNamingLower()
  28     {
  29         return new UnderscoreNamingStrategy(CASE_LOWER);
  30     }
  31
  32     /**
  33      * @return UnderscoreNamingStrategy
  34      */
  35     static private function underscoreNamingUpper()
  36     {
  37         return new UnderscoreNamingStrategy(CASE_UPPER);
  38     }
  39
  40     /**
  41      * Data Provider for NamingStrategy#classToTableName
  42      *
  43      * @return array
  44      */
  45     static public function dataClassToTableName()
  46     {
  47         return array(
  48             // DefaultNamingStrategy
  49             array(self::defaultNaming(), 'SomeClassName',
  50                 'SomeClassName'
  51             ),
  52             array(self::defaultNaming(), 'SomeClassName',
  53                 '\SomeClassName'
  54             ),
  55             array(self::defaultNaming(), 'Name',
  56                 '\Some\Class\Name'
  57             ),
  58
  59             // UnderscoreNamingStrategy
  60             array(self::underscoreNamingLower(), 'some_class_name',
  61                 '\Name\Space\SomeClassName'
  62             ),
  63             array(self::underscoreNamingLower(), 'name',
  64                 '\Some\Class\Name'
  65             ),
  66             array(self::underscoreNamingUpper(), 'SOME_CLASS_NAME',
  67                 '\Name\Space\SomeClassName'
  68             ),
  69             array(self::underscoreNamingUpper(), 'NAME',
  70                 '\Some\Class\Name'
  71             ),
  72         );
  73     }
  74
  75     /**
  76      * @dataProvider dataClassToTableName
  77      */
  78     public function testClassToTableName(NamingStrategy $strategy, $expected, $className)
  79     {
  80         $this->assertEquals($expected, $strategy->classToTableName($className));
  81     }
  82
  83     /**
  84      * Data Provider for NamingStrategy#propertyToColumnName
  85      *
  86      * @return array
  87      */
  88     static public function dataPropertyToColumnName()
  89     {
  90         return array(
  91             // DefaultNamingStrategy
  92             array(self::defaultNaming(), 'someProperty',
  93                 'someProperty'
  94             ),
  95             array(self::defaultNaming(), 'SOME_PROPERTY',
  96                 'SOME_PROPERTY'
  97             ),
  98             array(self::defaultNaming(), 'some_property',
  99                 'some_property'
 100             ),
 101
 102             // UnderscoreNamingStrategy
 103             array(self::underscoreNamingLower(), 'some_property',
 104                 'someProperty'
 105             ),
 106             array(self::underscoreNamingUpper(), 'SOME_PROPERTY',
 107                 'someProperty'
 108             ),
 109             array(self::underscoreNamingUpper(), 'SOME_PROPERTY',
 110                 'some_property'
 111             ),
 112             array(self::underscoreNamingUpper(), 'SOME_PROPERTY',
 113                 'SOME_PROPERTY'
 114             ),
 115         );
 116     }
 117
 118     /**
 119      * @dataProvider dataPropertyToColumnName
 120      *
 121      * @param NamingStrategy $strategy
 122      * @param string $expected
 123      * @param string $propertyName
 124      */
 125     public function testPropertyToColumnName(NamingStrategy $strategy, $expected, $propertyName)
 126     {
 127         $this->assertEquals($expected, $strategy->propertyToColumnName($propertyName));
 128     }
 129
 130     /**
 131      * Data Provider for NamingStrategy#referenceColumnName
 132      *
 133      * @return array
 134      */
 135     static public function dataReferenceColumnName()
 136     {
 137         return array(
 138             // DefaultNamingStrategy
 139             array(self::defaultNaming(), 'id'),
 140
 141             // UnderscoreNamingStrategy
 142             array(self::underscoreNamingLower(), 'id'),
 143             array(self::underscoreNamingUpper(), 'ID'),
 144         );
 145     }
 146
 147     /**
 148      * @dataProvider dataReferenceColumnName
 149      *
 150      * @param NamingStrategy $strategy
 151      * @param string $expected
 152      */
 153     public function testReferenceColumnName(NamingStrategy $strategy, $expected)
 154     {
 155         $this->assertEquals($expected, $strategy->referenceColumnName());
 156     }
 157
 158     /**
 159      * Data Provider for NamingStrategy#joinColumnName
 160      *
 161      * @return array
 162      */
 163     static public function dataJoinColumnName()
 164     {
 165         return array(
 166             // DefaultNamingStrategy
 167             array(self::defaultNaming(), 'someColumn_id',
 168                 'someColumn', null,
 169             ),
 170             array(self::defaultNaming(), 'some_column_id',
 171                 'some_column', null,
 172             ),
 173
 174             // UnderscoreNamingStrategy
 175             array(self::underscoreNamingLower(), 'some_column_id',
 176                 'someColumn', null,
 177             ),
 178             array(self::underscoreNamingUpper(), 'SOME_COLUMN_ID',
 179                 'someColumn', null,
 180             ),
 181         );
 182     }
 183
 184     /**
 185      * @dataProvider dataJoinColumnName
 186      *
 187      * @param NamingStrategy $strategy
 188      * @param string $expected
 189      * @param string $propertyName
 190      */
 191     public function testJoinColumnName(NamingStrategy $strategy, $expected, $propertyName)
 192     {
 193         $this->assertEquals($expected, $strategy->joinColumnName($propertyName));
 194     }
 195
 196     /**
 197      * Data Provider for NamingStrategy#joinTableName
 198      *
 199      * @return array
 200      */
 201     static public function dataJoinTableName()
 202     {
 203         return array(
 204             // DefaultNamingStrategy
 205             array(self::defaultNaming(), 'someclassname_classname',
 206                 'SomeClassName', 'Some\ClassName', null,
 207             ),
 208             array(self::defaultNaming(), 'someclassname_classname',
 209                 '\SomeClassName', 'ClassName', null,
 210             ),
 211             array(self::defaultNaming(), 'name_classname',
 212                 '\Some\Class\Name', 'ClassName', null,
 213             ),
 214
 215             // UnderscoreNamingStrategy
 216             array(self::underscoreNamingLower(), 'some_class_name_class_name',
 217                 'SomeClassName', 'Some\ClassName', null,
 218             ),
 219             array(self::underscoreNamingLower(), 'some_class_name_class_name',
 220                 '\SomeClassName', 'ClassName', null,
 221             ),
 222             array(self::underscoreNamingLower(), 'name_class_name',
 223                 '\Some\Class\Name', 'ClassName', null,
 224             ),
 225
 226             array(self::underscoreNamingUpper(), 'SOME_CLASS_NAME_CLASS_NAME',
 227                 'SomeClassName', 'Some\ClassName', null,
 228             ),
 229             array(self::underscoreNamingUpper(), 'SOME_CLASS_NAME_CLASS_NAME',
 230                 '\SomeClassName', 'ClassName', null,
 231             ),
 232             array(self::underscoreNamingUpper(), 'NAME_CLASS_NAME',
 233                 '\Some\Class\Name', 'ClassName', null,
 234             ),
 235         );
 236     }
 237
 238     /**
 239      * @dataProvider dataJoinTableName
 240      *
 241      * @param NamingStrategy $strategy
 242      * @param string $expected
 243      * @param string $ownerEntity
 244      * @param string $associatedEntity
 245      * @param string $propertyName
 246      */
 247     public function testJoinTableName(NamingStrategy $strategy, $expected, $ownerEntity, $associatedEntity, $propertyName = null)
 248     {
 249         $this->assertEquals($expected, $strategy->joinTableName($ownerEntity, $associatedEntity, $propertyName));
 250     }
 251
 252     /**
 253      * Data Provider for NamingStrategy#joinKeyColumnName
 254      *
 255      * @return array
 256      */
 257     static public function dataJoinKeyColumnName()
 258     {
 259         return array(
 260             // DefaultNamingStrategy
 261             array(self::defaultNaming(), 'someclassname_id',
 262                 'SomeClassName', null, null,
 263             ),
 264             array(self::defaultNaming(), 'name_identifier',
 265                 '\Some\Class\Name', 'identifier', null,
 266             ),
 267
 268             // UnderscoreNamingStrategy
 269             array(self::underscoreNamingLower(), 'some_class_name_id',
 270                 'SomeClassName', null, null,
 271             ),
 272             array(self::underscoreNamingLower(), 'class_name_identifier',
 273                 '\Some\Class\ClassName', 'identifier', null,
 274             ),
 275
 276             array(self::underscoreNamingUpper(), 'SOME_CLASS_NAME_ID',
 277                 'SomeClassName', null, null,
 278             ),
 279             array(self::underscoreNamingUpper(), 'CLASS_NAME_IDENTIFIER',
 280                 '\Some\Class\ClassName', 'IDENTIFIER', null,
 281             ),
 282         );
 283     }
 284
 285     /**
 286      * @dataProvider dataJoinKeyColumnName
 287      *
 288      * @param NamingStrategy $strategy
 289      * @param string $expected
 290      * @param string $propertyEntityName
 291      * @param string $referencedColumnName
 292      * @param string $propertyName
 293      */
 294     public function testJoinKeyColumnName(NamingStrategy $strategy, $expected, $propertyEntityName, $referencedColumnName = null, $propertyName = null)
 295     {
 296         $this->assertEquals($expected, $strategy->joinKeyColumnName($propertyEntityName, $referencedColumnName, $propertyName));
 297     }
 298 }