NamingStrategyTest::tablePrefixNaming() - Code Metrics - Inspection of "Add Pass Target Entity / Join Table Name to a refe..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7643)

unknown

created 2019-03-11 23:01 UTC

NamingStrategyTest::tablePrefixNaming() A

↳ Parent: NamingStrategyTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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\ORM\Mapping\NamingStrategy\TablePrefixNamingStrategy;
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 UnderscoreNamingStrategy
     */
    private static function underscoreNamingLower()
    {
        return new UnderscoreNamingStrategy(CASE_LOWER);
    }

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

    /**
     * @return TablePrefixNamingStrategy
     */
    private static function tablePrefixNaming()
    {
        return new TablePrefixNamingStrategy();
    }

    /**
     * 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',
            ],

            // 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',
            ],

            // TablePrefixNamingStrategy
            [
                self::tablePrefixNaming(),
                'SomeClassName',
                'SomeClassName',
            ],
            [
                self::tablePrefixNaming(),
                'SomeClassName',
                '\SomeClassName',
            ],
            [
                self::tablePrefixNaming(),
                'Name',
                '\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',
                null,
            ],
            [
                self::defaultNaming(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
                null,
            ],
            [
                self::defaultNaming(),
                'some_property',
                'some_property',
                null,
            ],

            // UnderscoreNamingStrategy
            [
                self::underscoreNamingLower(),
                'some_property',
                'someProperty',
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'someProperty',
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'some_property',
                null,
            ],
            [
                self::underscoreNamingUpper(),
                'SOME_PROPERTY',
                'SOME_PROPERTY',
                null,
            ],

            // TablePrefixNamingStrategy
            [
                self::tablePrefixNaming(),
                'Entity_someProperty',
                'someProperty',
                'Some\Entity',
            ],
            [
                self::tablePrefixNaming(),
                'ENTITY_SOME_PROPERTY',
                'SOME_PROPERTY',
                'SOME\ENTITY',
            ],
            [
                self::tablePrefixNaming(),
                'entity_some_property',
                'some_property',
                'some\entity',
            ],
        ];
    }

    /**
     * @param string $expected

     * @param string $propertyName

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

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

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

            // TablePrefixNamingStrategy
            [self::tablePrefixNaming(), 'Entity_id', 'Some\Entity'],
        ];
    }

    /**
     * @param string $expected

     * @param string|null $targetEntity
     *
     * @dataProvider dataReferenceColumnName
     */
    public function testReferenceColumnName(NamingStrategy $strategy, $expected, $targetEntity): void

    {
        self::assertEquals($expected, $strategy->referenceColumnName($targetEntity));
    }

    /**
     * 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],

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

            // TablePrefixNamingStrategy
            [self::tablePrefixNaming(), 'ClassName_someColumn_id', 'someColumn', 'Some\ClassName'],
            [self::tablePrefixNaming(), 'ClassName_some_column_id', 'some_column', 'ClassName'],
        ];
    }

    /**
     * @param string $expected

     * @param string $propertyName

     * @param string|null $className
     *
     * @dataProvider dataJoinColumnName
     */
    public function testJoinColumnName(NamingStrategy $strategy, $expected, $propertyName, $className) : 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,
            ],

            // 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,
            ],

            // TablePrefixNamingStrategy
            [
                self::tablePrefixNaming(),
                'someclassname_classname',
                'SomeClassName',
                'Some\ClassName',
                null,
            ],
            [
                self::tablePrefixNaming(),
                'someclassname_classname',
                '\SomeClassName',
                'ClassName',
                null,
            ],
            [
                self::tablePrefixNaming(),
                'name_classname',
                '\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,
            ],

            // 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,
            ],

            // TablePrefixNamingStrategy
            [
                self::tablePrefixNaming(),
                'someclass_someanotherclass_someclassname_id',
                'SomeClassName',
                null,
                'someclass_someanotherclass',
            ],
            [
                self::tablePrefixNaming(),
                'someclass_someanotherclass_name_identifier',
                '\Some\Class\Name',
                'identifier',
                'someclass_someanotherclass',
            ],
        ];
    }

    /**
     * @param string $expected

     * @param string $propertyEntityName

     * @param string $referencedColumnName

     * @param string|null $joinTableName
     *
     * @dataProvider dataJoinKeyColumnName
     */
    public function testJoinKeyColumnName(NamingStrategy $strategy, $expected, $propertyEntityName, $referencedColumnName = null, $joinTableName) : void
// $a must always be passed; it's default value is never used.
function someFunction($a = 5, $b) { }
    {
        self::assertEquals($expected, $strategy->joinKeyColumnName($propertyEntityName, $referencedColumnName, $joinTableName));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Tests\ORM\Mapping;
6
7			use Doctrine\ORM\Mapping\Factory\DefaultNamingStrategy;
8			use Doctrine\ORM\Mapping\Factory\NamingStrategy;
9			use Doctrine\ORM\Mapping\Factory\UnderscoreNamingStrategy;
10			use Doctrine\Tests\ORM\Mapping\NamingStrategy\JoinColumnClassNamingStrategy;
11			use Doctrine\Tests\ORM\Mapping\NamingStrategy\TablePrefixNamingStrategy;
12			use Doctrine\Tests\OrmTestCase;
13			use const CASE_LOWER;
14			use const CASE_UPPER;
15
16			/**
17			* @group DDC-559
18			*/
19			class NamingStrategyTest extends OrmTestCase
20			{
21			/**
22			* @return DefaultNamingStrategy
23			*/
24			private static function defaultNaming()
25			{
26			return new DefaultNamingStrategy();
27			}
28
29			/**
30			* @return UnderscoreNamingStrategy
31			*/
32			private static function underscoreNamingLower()
33			{
34			return new UnderscoreNamingStrategy(CASE_LOWER);
35			}
36
37			/**
38			* @return UnderscoreNamingStrategy
39			*/
40			private static function underscoreNamingUpper()
41			{
42			return new UnderscoreNamingStrategy(CASE_UPPER);
43			}
44
45			/**
46			* @return TablePrefixNamingStrategy
47			*/
48			private static function tablePrefixNaming()
49			{
50			return new TablePrefixNamingStrategy();
51			}
52
53			/**
54			* Data Provider for NamingStrategy#classToTableName
55			*
56			* @return array
57			*/
58			public static function dataClassToTableName()
59			{
60			return [
61			// DefaultNamingStrategy
62			[
63			self::defaultNaming(),
64			'SomeClassName',
65			'SomeClassName',
66			],
67			[
68			self::defaultNaming(),
69			'SomeClassName',
70			'\SomeClassName',
71			],
72			[
73			self::defaultNaming(),
74			'Name',
75			'\Some\Class\Name',
76			],
77
78			// UnderscoreNamingStrategy
79			[
80			self::underscoreNamingLower(),
81			'some_class_name',
82			'\Name\Space\SomeClassName',
83			],
84			[
85			self::underscoreNamingLower(),
86			'name',
87			'\Some\Class\Name',
88			],
89			[
90			self::underscoreNamingUpper(),
91			'SOME_CLASS_NAME',
92			'\Name\Space\SomeClassName',
93			],
94			[
95			self::underscoreNamingUpper(),
96			'NAME',
97			'\Some\Class\Name',
98			],
99
100			// TablePrefixNamingStrategy
101			[
102			self::tablePrefixNaming(),
103			'SomeClassName',
104			'SomeClassName',
105			],
106			[
107			self::tablePrefixNaming(),
108			'SomeClassName',
109			'\SomeClassName',
110			],
111			[
112			self::tablePrefixNaming(),
113			'Name',
114			'\Some\Class\Name',
115			],
116			];
117			}
118
119			/**
120			* @dataProvider dataClassToTableName
121			*/
122			public function testClassToTableName(NamingStrategy $strategy, $expected, $className) : void
123			{
124			self::assertEquals($expected, $strategy->classToTableName($className));
125			}
126
127			/**
128			* Data Provider for NamingStrategy#propertyToColumnName
129			*
130			* @return array
131			*/
132			public static function dataPropertyToColumnName()
133			{
134			return [
135			// DefaultNamingStrategy
136			[
137			self::defaultNaming(),
138			'someProperty',
139			'someProperty',
140			null,
141			],
142			[
143			self::defaultNaming(),
144			'SOME_PROPERTY',
145			'SOME_PROPERTY',
146			null,
147			],
148			[
149			self::defaultNaming(),
150			'some_property',
151			'some_property',
152			null,
153			],
154
155			// UnderscoreNamingStrategy
156			[
157			self::underscoreNamingLower(),
158			'some_property',
159			'someProperty',
160			null,
161			],
162			[
163			self::underscoreNamingUpper(),
164			'SOME_PROPERTY',
165			'someProperty',
166			null,
167			],
168			[
169			self::underscoreNamingUpper(),
170			'SOME_PROPERTY',
171			'some_property',
172			null,
173			],
174			[
175			self::underscoreNamingUpper(),
176			'SOME_PROPERTY',
177			'SOME_PROPERTY',
178			null,
179			],
180
181			// TablePrefixNamingStrategy
182			[
183			self::tablePrefixNaming(),
184			'Entity_someProperty',
185			'someProperty',
186			'Some\Entity',
187			],
188			[
189			self::tablePrefixNaming(),
190			'ENTITY_SOME_PROPERTY',
191			'SOME_PROPERTY',
192			'SOME\ENTITY',
193			],
194			[
195			self::tablePrefixNaming(),
196			'entity_some_property',
197			'some_property',
198			'some\entity',
199			],
200			];
201			}
202
203			/**
204			* @param string $expected
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
205			* @param string $propertyName
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
206			* @param string\|null $className
207			*
208			* @dataProvider dataPropertyToColumnName
209			*/
210			public function testPropertyToColumnName(NamingStrategy $strategy, $expected, $propertyName, $className) : void
211			{
212			self::assertEquals($expected, $strategy->propertyToColumnName($propertyName, $className));
213			}
214
215			/**
216			* Data Provider for NamingStrategy#referenceColumnName
217			*
218			* @return array
219			*/
220			public static function dataReferenceColumnName()
221			{
222			return [
223			// DefaultNamingStrategy
224			[self::defaultNaming(), 'id', null],
225
226			// UnderscoreNamingStrategy
227			[self::underscoreNamingLower(), 'id', null],
228			[self::underscoreNamingUpper(), 'ID', null],
229
230			// TablePrefixNamingStrategy
231			[self::tablePrefixNaming(), 'Entity_id', 'Some\Entity'],
232			];
233			}
234
235			/**
236			* @param string $expected
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
237			* @param string\|null $targetEntity
238			*
239			* @dataProvider dataReferenceColumnName
240			*/
241			public function testReferenceColumnName(NamingStrategy $strategy, $expected, $targetEntity): void
			0 ignored issues – show introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report There must be exactly 1 whitespace between closing parenthesis and return type colon. Loading history...
242			{
243			self::assertEquals($expected, $strategy->referenceColumnName($targetEntity));
244			}
245
246			/**
247			* Data Provider for NamingStrategy#joinColumnName
248			*
249			* @return array
250			*/
251			public static function dataJoinColumnName()
252			{
253			return [
254			// DefaultNamingStrategy
255			[self::defaultNaming(), 'someColumn_id', 'someColumn', null],
256			[self::defaultNaming(), 'some_column_id', 'some_column', null],
257
258			// UnderscoreNamingStrategy
259			[self::underscoreNamingLower(), 'some_column_id', 'someColumn', null],
260			[self::underscoreNamingUpper(), 'SOME_COLUMN_ID', 'someColumn', null],
261			// JoinColumnClassNamingStrategy
262			[new JoinColumnClassNamingStrategy(), 'classname_someColumn_id', 'someColumn', 'Some\ClassName'],
263			[new JoinColumnClassNamingStrategy(), 'classname_some_column_id', 'some_column', 'ClassName'],
264
265			// TablePrefixNamingStrategy
266			[self::tablePrefixNaming(), 'ClassName_someColumn_id', 'someColumn', 'Some\ClassName'],
267			[self::tablePrefixNaming(), 'ClassName_some_column_id', 'some_column', 'ClassName'],
268			];
269			}
270
271			/**
272			* @param string $expected
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
273			* @param string $propertyName
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
274			* @param string\|null $className
275			*
276			* @dataProvider dataJoinColumnName
277			*/
278			public function testJoinColumnName(NamingStrategy $strategy, $expected, $propertyName, $className) : void
279			{
280			self::assertEquals($expected, $strategy->joinColumnName($propertyName, $className));
281			}
282
283			/**
284			* Data Provider for NamingStrategy#joinTableName
285			*
286			* @return array
287			*/
288			public static function dataJoinTableName()
289			{
290			return [
291			// DefaultNamingStrategy
292			[
293			self::defaultNaming(),
294			'someclassname_classname',
295			'SomeClassName',
296			'Some\ClassName',
297			null,
298			],
299			[
300			self::defaultNaming(),
301			'someclassname_classname',
302			'\SomeClassName',
303			'ClassName',
304			null,
305			],
306			[
307			self::defaultNaming(),
308			'name_classname',
309			'\Some\Class\Name',
310			'ClassName',
311			null,
312			],
313
314			// UnderscoreNamingStrategy
315			[
316			self::underscoreNamingLower(),
317			'some_class_name_class_name',
318			'SomeClassName',
319			'Some\ClassName',
320			null,
321			],
322			[
323			self::underscoreNamingLower(),
324			'some_class_name_class_name',
325			'\SomeClassName',
326			'ClassName',
327			null,
328			],
329			[
330			self::underscoreNamingLower(),
331			'name_class_name',
332			'\Some\Class\Name',
333			'ClassName',
334			null,
335			],
336
337			[
338			self::underscoreNamingUpper(),
339			'SOME_CLASS_NAME_CLASS_NAME',
340			'SomeClassName',
341			'Some\ClassName',
342			null,
343			],
344			[
345			self::underscoreNamingUpper(),
346			'SOME_CLASS_NAME_CLASS_NAME',
347			'\SomeClassName',
348			'ClassName',
349			null,
350			],
351			[
352			self::underscoreNamingUpper(),
353			'NAME_CLASS_NAME',
354			'\Some\Class\Name',
355			'ClassName',
356			null,
357			],
358
359			// TablePrefixNamingStrategy
360			[
361			self::tablePrefixNaming(),
362			'someclassname_classname',
363			'SomeClassName',
364			'Some\ClassName',
365			null,
366			],
367			[
368			self::tablePrefixNaming(),
369			'someclassname_classname',
370			'\SomeClassName',
371			'ClassName',
372			null,
373			],
374			[
375			self::tablePrefixNaming(),
376			'name_classname',
377			'\Some\Class\Name',
378			'ClassName',
379			null,
380			],
381			];
382			}
383
384			/**
385			* @param string $expected
386			* @param string $ownerEntity
387			* @param string $associatedEntity
388			* @param string $propertyName
389			*
390			* @dataProvider dataJoinTableName
391			*/
392			public function testJoinTableName(NamingStrategy $strategy, $expected, $ownerEntity, $associatedEntity, $propertyName = null) : void
393			{
394			self::assertEquals($expected, $strategy->joinTableName($ownerEntity, $associatedEntity, $propertyName));
395			}
396
397			/**
398			* Data Provider for NamingStrategy#joinKeyColumnName
399			*
400			* @return array
401			*/
402			public static function dataJoinKeyColumnName()
403			{
404			return [
405			// DefaultNamingStrategy
406			[
407			self::defaultNaming(),
408			'someclassname_id',
409			'SomeClassName',
410			null,
411			null,
412			],
413			[
414			self::defaultNaming(),
415			'name_identifier',
416			'\Some\Class\Name',
417			'identifier',
418			null,
419			],
420
421			// UnderscoreNamingStrategy
422			[
423			self::underscoreNamingLower(),
424			'some_class_name_id',
425			'SomeClassName',
426			null,
427			null,
428			],
429			[
430			self::underscoreNamingLower(),
431			'class_name_identifier',
432			'\Some\Class\ClassName',
433			'identifier',
434			null,
435			],
436
437			[
438			self::underscoreNamingUpper(),
439			'SOME_CLASS_NAME_ID',
440			'SomeClassName',
441			null,
442			null,
443			],
444			[
445			self::underscoreNamingUpper(),
446			'CLASS_NAME_IDENTIFIER',
447			'\Some\Class\ClassName',
448			'IDENTIFIER',
449			null,
450			],
451
452			// TablePrefixNamingStrategy
453			[
454			self::tablePrefixNaming(),
455			'someclass_someanotherclass_someclassname_id',
456			'SomeClassName',
457			null,
458			'someclass_someanotherclass',
459			],
460			[
461			self::tablePrefixNaming(),
462			'someclass_someanotherclass_name_identifier',
463			'\Some\Class\Name',
464			'identifier',
465			'someclass_someanotherclass',
466			],
467			];
468			}
469
470			/**
471			* @param string $expected
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
472			* @param string $propertyEntityName
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
473			* @param string $referencedColumnName
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Expected 6 spaces after parameter type; 1 found Loading history...
474			* @param string\|null $joinTableName
475			*
476			* @dataProvider dataJoinKeyColumnName
477			*/
478			public function testJoinKeyColumnName(NamingStrategy $strategy, $expected, $propertyEntityName, $referencedColumnName = null, $joinTableName) : void
			0 ignored issues – show Coding Style introduced 2019-03-11 23:10 UTC by Report Bug Copy Issue Report Parameters which have default values should be placed at the end. If you place a parameter with a default value before a parameter with a default value, the default value of the first parameter will never be used as it will always need to be passed anyway: // $a must always be passed; it's default value is never used. function someFunction($a = 5, $b) { } Loading history...
479			{
480			self::assertEquals($expected, $strategy->joinKeyColumnName($propertyEntityName, $referencedColumnName, $joinTableName));
481			}
482			}
483

doctrine / orm

Pull Request — master (#7643)

NamingStrategyTest::tablePrefixNaming() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like