Total Complexity | 56 |
Total Lines | 1035 |
Duplicated Lines | 0 % |
Changes | 3 | ||
Bugs | 0 | Features | 0 |
Complex classes like AbstractMappingDriverTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use AbstractMappingDriverTest, and based on these observations, apply Extract Interface, too.
1 | <?php |
||
48 | abstract class AbstractMappingDriverTest extends OrmTestCase |
||
49 | { |
||
50 | /** @var AbstractPlatform */ |
||
51 | protected $targetPlatform; |
||
52 | |||
53 | /** @var Mapping\ClassMetadataBuildingContext */ |
||
54 | protected $metadataBuildingContext; |
||
55 | |||
56 | protected function setUp() : void |
||
57 | { |
||
58 | parent::setUp(); |
||
59 | |||
60 | $this->targetPlatform = $this->createMock(AbstractPlatform::class); |
||
61 | |||
62 | $this->targetPlatform |
||
63 | ->expects($this->any()) |
||
64 | ->method('prefersSequences') |
||
65 | ->will($this->returnValue(true)); |
||
66 | |||
67 | $this->targetPlatform |
||
68 | ->expects($this->any()) |
||
69 | ->method('usesSequenceEmulatedIdentityColumns') |
||
70 | ->will($this->returnValue(true)); |
||
71 | |||
72 | $this->targetPlatform |
||
73 | ->expects($this->any()) |
||
74 | ->method('fixSchemaElementName') |
||
75 | ->will($this->returnArgument(0)); |
||
76 | |||
77 | $this->metadataBuildingContext = new Mapping\ClassMetadataBuildingContext( |
||
78 | $this->createMock(ClassMetadataFactory::class), |
||
79 | $this->createMock(ReflectionService::class), |
||
80 | $this->targetPlatform |
||
81 | ); |
||
82 | } |
||
83 | |||
84 | abstract protected function loadDriver(); |
||
85 | |||
86 | public function createClassMetadata($entityClassName) |
||
87 | { |
||
88 | $mappingDriver = $this->loadDriver(); |
||
89 | |||
90 | return $mappingDriver->loadMetadataForClass($entityClassName, null, $this->metadataBuildingContext); |
||
91 | } |
||
92 | |||
93 | protected function createClassMetadataFactory(?EntityManagerInterface $em = null) : ClassMetadataFactory |
||
94 | { |
||
95 | $driver = $this->loadDriver(); |
||
96 | $em = $em ?: $this->getTestEntityManager(); |
||
97 | $factory = new ClassMetadataFactory(); |
||
98 | |||
99 | $em->getConfiguration()->setMetadataDriverImpl($driver); |
||
100 | $factory->setEntityManager($em); |
||
101 | |||
102 | return $factory; |
||
103 | } |
||
104 | |||
105 | public function testEntityTableNameAndInheritance() : ClassMetadata |
||
106 | { |
||
107 | $class = $this->createClassMetadata(User::class); |
||
108 | |||
109 | self::assertEquals('cms_users', $class->getTableName()); |
||
110 | self::assertEquals(Mapping\InheritanceType::NONE, $class->inheritanceType); |
||
111 | |||
112 | return $class; |
||
113 | } |
||
114 | |||
115 | public function testEntityIndexes() : ClassMetadata |
||
116 | { |
||
117 | $class = $this->createClassMetadata('Doctrine\Tests\ORM\Mapping\User'); |
||
118 | |||
119 | self::assertCount(2, $class->table->getIndexes()); |
||
120 | self::assertEquals( |
||
121 | [ |
||
122 | 'name_idx' => [ |
||
123 | 'name' => 'name_idx', |
||
124 | 'columns' => ['name'], |
||
125 | 'unique' => false, |
||
126 | 'options' => [], |
||
127 | 'flags' => [], |
||
128 | ], |
||
129 | 0 => [ |
||
130 | 'name' => null, |
||
131 | 'columns' => ['user_email'], |
||
132 | 'unique' => false, |
||
133 | 'options' => [], |
||
134 | 'flags' => [], |
||
135 | ], |
||
136 | ], |
||
137 | $class->table->getIndexes() |
||
138 | ); |
||
139 | |||
140 | return $class; |
||
141 | } |
||
142 | |||
143 | public function testEntityIndexFlagsAndPartialIndexes() : void |
||
144 | { |
||
145 | $class = $this->createClassMetadata(Comment::class); |
||
146 | |||
147 | self::assertEquals( |
||
148 | [ |
||
149 | 0 => [ |
||
150 | 'name' => null, |
||
151 | 'columns' => ['content'], |
||
152 | 'unique' => false, |
||
153 | 'flags' => ['fulltext'], |
||
154 | 'options' => ['where' => 'content IS NOT NULL'], |
||
155 | ], |
||
156 | ], |
||
157 | $class->table->getIndexes() |
||
158 | ); |
||
159 | } |
||
160 | |||
161 | /** |
||
162 | * @param ClassMetadata $class |
||
163 | * |
||
164 | * @depends testEntityTableNameAndInheritance |
||
165 | */ |
||
166 | public function testEntityUniqueConstraints($class) : ClassMetadata |
||
167 | { |
||
168 | self::assertCount(1, $class->table->getUniqueConstraints()); |
||
169 | self::assertEquals( |
||
170 | [ |
||
171 | 'search_idx' => [ |
||
172 | 'name' => 'search_idx', |
||
173 | 'columns' => ['name', 'user_email'], |
||
174 | 'options' => [], |
||
175 | 'flags' => [], |
||
176 | ], |
||
177 | ], |
||
178 | $class->table->getUniqueConstraints() |
||
179 | ); |
||
180 | |||
181 | return $class; |
||
182 | } |
||
183 | |||
184 | /** |
||
185 | * @param ClassMetadata $class |
||
186 | * |
||
187 | * @depends testEntityTableNameAndInheritance |
||
188 | */ |
||
189 | public function testEntityOptions($class) : ClassMetadata |
||
190 | { |
||
191 | self::assertCount(2, $class->table->getOptions()); |
||
192 | self::assertEquals( |
||
193 | [ |
||
194 | 'foo' => 'bar', |
||
195 | 'baz' => ['key' => 'val'], |
||
196 | ], |
||
197 | $class->table->getOptions() |
||
198 | ); |
||
199 | |||
200 | return $class; |
||
201 | } |
||
202 | |||
203 | /** |
||
204 | * @param ClassMetadata $class |
||
205 | * |
||
206 | * @depends testEntityOptions |
||
207 | */ |
||
208 | public function testEntitySequence($class) : void |
||
209 | { |
||
210 | $valueGenerator = $class->getProperty('id')->getValueGenerator(); |
||
|
|||
211 | |||
212 | self::assertEquals(Mapping\GeneratorType::SEQUENCE, $valueGenerator->getType(), 'Generator Type'); |
||
213 | self::assertInstanceOf(SequenceGenerator::class, $valueGenerator->getGenerator(), 'No Sequence Definition set on this driver.'); |
||
214 | |||
215 | /** @var SequenceGenerator $generator */ |
||
216 | $generator = $valueGenerator->getGenerator(); |
||
217 | |||
218 | self::assertEquals('tablename_seq', $generator->getSequenceName()); |
||
219 | self::assertEquals(100, $generator->getAllocationSize()); |
||
220 | } |
||
221 | |||
222 | public function testEntityCustomGenerator() : void |
||
223 | { |
||
224 | $class = $this->createClassMetadata(Animal::class); |
||
225 | $valueGenerator = $class->getProperty('id')->getValueGenerator(); |
||
226 | |||
227 | self::assertEquals(Mapping\GeneratorType::CUSTOM, $valueGenerator->getType(), 'Generator Type'); |
||
228 | self::assertInstanceOf(CustomGenerator::class, $valueGenerator->getGenerator(), 'Generator Definition'); |
||
229 | } |
||
230 | |||
231 | /** |
||
232 | * @param ClassMetadata $class |
||
233 | * |
||
234 | * @depends testEntityTableNameAndInheritance |
||
235 | */ |
||
236 | public function testProperties($class) : ClassMetadata |
||
237 | { |
||
238 | self::assertCount(7, $class->getPropertiesIterator()); |
||
239 | |||
240 | self::assertNotNull($class->getProperty('id')); |
||
241 | self::assertNotNull($class->getProperty('name')); |
||
242 | self::assertNotNull($class->getProperty('email')); |
||
243 | self::assertNotNull($class->getProperty('version')); |
||
244 | self::assertNotNull($class->getProperty('version')); |
||
245 | |||
246 | return $class; |
||
247 | } |
||
248 | |||
249 | /** |
||
250 | * @param ClassMetadata $class |
||
251 | * |
||
252 | * @depends testProperties |
||
253 | */ |
||
254 | public function testVersionProperty($class) : void |
||
255 | { |
||
256 | self::assertTrue($class->isVersioned()); |
||
257 | self::assertNotNull($class->versionProperty); |
||
258 | |||
259 | $versionPropertyName = $class->versionProperty->getName(); |
||
260 | |||
261 | self::assertEquals('version', $versionPropertyName); |
||
262 | self::assertNotNull($class->getProperty($versionPropertyName)); |
||
263 | } |
||
264 | |||
265 | /** |
||
266 | * @param ClassMetadata $class |
||
267 | * |
||
268 | * @depends testEntityTableNameAndInheritance |
||
269 | */ |
||
270 | public function testFieldMappingsColumnNames($class) : ClassMetadata |
||
271 | { |
||
272 | self::assertNotNull($class->getProperty('id')); |
||
273 | self::assertNotNull($class->getProperty('name')); |
||
274 | self::assertNotNull($class->getProperty('email')); |
||
275 | |||
276 | self::assertEquals('id', $class->getProperty('id')->getColumnName()); |
||
277 | self::assertEquals('name', $class->getProperty('name')->getColumnName()); |
||
278 | self::assertEquals('user_email', $class->getProperty('email')->getColumnName()); |
||
279 | |||
280 | return $class; |
||
281 | } |
||
282 | |||
283 | /** |
||
284 | * @param ClassMetadata $class |
||
285 | * |
||
286 | * @depends testEntityTableNameAndInheritance |
||
287 | */ |
||
288 | public function testStringFieldMappings($class) : ClassMetadata |
||
289 | { |
||
290 | self::assertNotNull($class->getProperty('name')); |
||
291 | |||
292 | $property = $class->getProperty('name'); |
||
293 | |||
294 | self::assertEquals('string', $property->getTypeName()); |
||
295 | self::assertEquals(50, $property->getLength()); |
||
296 | self::assertTrue($property->isNullable()); |
||
297 | self::assertTrue($property->isUnique()); |
||
298 | |||
299 | return $class; |
||
300 | } |
||
301 | |||
302 | /** |
||
303 | * @depends testEntityTableNameAndInheritance |
||
304 | */ |
||
305 | public function testFieldOptions(ClassMetadata $class) : ClassMetadata |
||
306 | { |
||
307 | self::assertNotNull($class->getProperty('name')); |
||
308 | |||
309 | $property = $class->getProperty('name'); |
||
310 | $expected = ['foo' => 'bar', 'baz' => ['key' => 'val'], 'fixed' => false]; |
||
311 | |||
312 | self::assertEquals($expected, $property->getOptions()); |
||
313 | |||
314 | return $class; |
||
315 | } |
||
316 | |||
317 | /** |
||
318 | * @param ClassMetadata $class |
||
319 | * |
||
320 | * @depends testEntityTableNameAndInheritance |
||
321 | */ |
||
322 | public function testIdFieldOptions($class) : ClassMetadata |
||
323 | { |
||
324 | self::assertNotNull($class->getProperty('id')); |
||
325 | |||
326 | $property = $class->getProperty('id'); |
||
327 | $expected = ['foo' => 'bar', 'unsigned' => false]; |
||
328 | |||
329 | self::assertEquals($expected, $property->getOptions()); |
||
330 | |||
331 | return $class; |
||
332 | } |
||
333 | |||
334 | /** |
||
335 | * @param ClassMetadata $class |
||
336 | * |
||
337 | * @depends testProperties |
||
338 | */ |
||
339 | public function testIdentifier($class) : ClassMetadata |
||
354 | } |
||
355 | |||
356 | /** |
||
357 | * @group #6129 |
||
358 | */ |
||
359 | public function testBooleanValuesForOptionIsSetCorrectly() : ClassMetadata |
||
360 | { |
||
361 | $class = $this->createClassMetadata(User::class); |
||
362 | |||
363 | $idOptions = $class->getProperty('id')->getOptions(); |
||
364 | $nameOptions = $class->getProperty('name')->getOptions(); |
||
365 | |||
366 | self::assertInternalType('bool', $idOptions['unsigned']); |
||
367 | self::assertFalse($idOptions['unsigned']); |
||
368 | self::assertInternalType('bool', $nameOptions['fixed']); |
||
369 | self::assertFalse($nameOptions['fixed']); |
||
370 | |||
371 | return $class; |
||
372 | } |
||
373 | |||
374 | public function testOneToOneUnidirectional() : void |
||
375 | { |
||
376 | // One to One owning |
||
377 | $fullAddressClass = $this->createClassMetadata(Quote\FullAddress::class); |
||
378 | $cityAssociation = $fullAddressClass->getProperty('city'); |
||
379 | |||
380 | self::assertInstanceOf(Mapping\OneToOneAssociationMetadata::class, $cityAssociation); |
||
381 | self::assertTrue($cityAssociation->isOwningSide()); |
||
382 | } |
||
383 | |||
384 | public function testOneToOneBidirectional() : void |
||
385 | { |
||
386 | // One to One owning / One To One inverse |
||
387 | $addressClass = $this->createClassMetadata(Quote\Address::class); |
||
388 | $userAssociation = $addressClass->getProperty('user'); |
||
389 | |||
390 | self::assertInstanceOf(Mapping\OneToOneAssociationMetadata::class, $userAssociation); |
||
391 | self::assertTrue($userAssociation->isOwningSide()); |
||
392 | |||
393 | $userClass = $this->createClassMetadata(Quote\User::class); |
||
394 | $addressAssociation = $userClass->getProperty('address'); |
||
395 | |||
396 | self::assertInstanceOf(Mapping\OneToOneAssociationMetadata::class, $addressAssociation); |
||
397 | self::assertFalse($addressAssociation->isOwningSide()); |
||
398 | } |
||
399 | |||
400 | public function testManyToOneUnidirectional() : void |
||
401 | { |
||
402 | // Many to One owning |
||
403 | $groupClass = $this->createClassMetadata(Quote\Group::class); |
||
404 | $groupAssociation = $groupClass->getProperty('parent'); |
||
405 | |||
406 | self::assertInstanceOf(Mapping\ManyToOneAssociationMetadata::class, $groupAssociation); |
||
407 | self::assertTrue($groupAssociation->isOwningSide()); |
||
408 | } |
||
409 | |||
410 | public function testManyToOneBidirectional() : void |
||
411 | { |
||
412 | // Many To One owning / One To Many inverse |
||
413 | $phoneClass = $this->createClassMetadata(Quote\Phone::class); |
||
414 | $userAssociation = $phoneClass->getProperty('user'); |
||
415 | |||
416 | self::assertInstanceOf(Mapping\ManyToOneAssociationMetadata::class, $userAssociation); |
||
417 | self::assertTrue($userAssociation->isOwningSide()); |
||
418 | |||
419 | $userClass = $this->createClassMetadata(Quote\User::class); |
||
420 | $phoneAssociation = $userClass->getProperty('phones'); |
||
421 | |||
422 | self::assertInstanceOf(Mapping\OneToManyAssociationMetadata::class, $phoneAssociation); |
||
423 | self::assertFalse($phoneAssociation->isOwningSide()); |
||
424 | } |
||
425 | |||
426 | public function testManyToManyBidirectional() : void |
||
427 | { |
||
428 | // Many to Many owning / Many to Many inverse |
||
429 | $userClass = $this->createClassMetadata(Quote\User::class); |
||
430 | $groupAssociation = $userClass->getProperty('groups'); |
||
431 | |||
432 | self::assertInstanceOf(Mapping\ManyToManyAssociationMetadata::class, $groupAssociation); |
||
433 | self::assertTrue($groupAssociation->isOwningSide()); |
||
434 | |||
435 | $groupClass = $this->createClassMetadata(Quote\Group::class); |
||
436 | $userAssociation = $groupClass->getProperty('users'); |
||
437 | |||
438 | self::assertInstanceOf(Mapping\ManyToManyAssociationMetadata::class, $userAssociation); |
||
439 | self::assertFalse($userAssociation->isOwningSide()); |
||
440 | } |
||
441 | |||
442 | /** |
||
443 | * @param ClassMetadata $class |
||
444 | * |
||
445 | * @depends testProperties |
||
446 | */ |
||
447 | public function testOwningOneToOneAssociation($class) : ClassMetadata |
||
448 | { |
||
449 | self::assertArrayHasKey('address', iterator_to_array($class->getPropertiesIterator())); |
||
450 | |||
451 | $association = $class->getProperty('address'); |
||
452 | |||
453 | self::assertTrue($association->isOwningSide()); |
||
454 | self::assertEquals('user', $association->getInversedBy()); |
||
455 | // Check cascading |
||
456 | self::assertEquals(['remove'], $association->getCascade()); |
||
457 | |||
458 | return $class; |
||
459 | } |
||
460 | |||
461 | /** |
||
462 | * @param ClassMetadata $class |
||
463 | * |
||
464 | * @depends testOwningOneToOneAssociation |
||
465 | */ |
||
466 | public function testInverseOneToManyAssociation($class) : ClassMetadata |
||
467 | { |
||
468 | self::assertArrayHasKey('phonenumbers', iterator_to_array($class->getPropertiesIterator())); |
||
469 | |||
470 | $association = $class->getProperty('phonenumbers'); |
||
471 | |||
472 | self::assertFalse($association->isOwningSide()); |
||
473 | self::assertTrue($association->isOrphanRemoval()); |
||
474 | |||
475 | // Check cascading |
||
476 | self::assertEquals(['persist', 'remove'], $association->getCascade()); |
||
477 | |||
478 | // Test Order By |
||
479 | self::assertEquals(['number' => 'ASC'], $association->getOrderBy()); |
||
480 | |||
481 | return $class; |
||
482 | } |
||
483 | |||
484 | /** |
||
485 | * @param ClassMetadata $class |
||
486 | * |
||
487 | * @depends testInverseOneToManyAssociation |
||
488 | */ |
||
489 | public function testManyToManyAssociationWithCascadeAll($class) : ClassMetadata |
||
490 | { |
||
491 | self::assertArrayHasKey('groups', iterator_to_array($class->getPropertiesIterator())); |
||
492 | |||
493 | $association = $class->getProperty('groups'); |
||
494 | |||
495 | self::assertTrue($association->isOwningSide()); |
||
496 | |||
497 | // Make sure that cascade-all works as expected |
||
498 | self::assertEquals(['remove', 'persist', 'refresh'], $association->getCascade()); |
||
499 | |||
500 | // Test Order By |
||
501 | self::assertEquals([], $association->getOrderBy()); |
||
502 | |||
503 | return $class; |
||
504 | } |
||
505 | |||
506 | /** |
||
507 | * @param ClassMetadata $class |
||
508 | * |
||
509 | * @depends testManyToManyAssociationWithCascadeAll |
||
510 | */ |
||
511 | public function testLifecycleCallbacks($class) : ClassMetadata |
||
512 | { |
||
513 | self::assertCount(2, $class->lifecycleCallbacks); |
||
514 | self::assertEquals($class->lifecycleCallbacks['prePersist'][0], 'doStuffOnPrePersist'); |
||
515 | self::assertEquals($class->lifecycleCallbacks['postPersist'][0], 'doStuffOnPostPersist'); |
||
516 | |||
517 | return $class; |
||
518 | } |
||
519 | |||
520 | /** |
||
521 | * @param ClassMetadata $class |
||
522 | * |
||
523 | * @depends testManyToManyAssociationWithCascadeAll |
||
524 | */ |
||
525 | public function testLifecycleCallbacksSupportMultipleMethodNames($class) : ClassMetadata |
||
526 | { |
||
527 | self::assertCount(2, $class->lifecycleCallbacks['prePersist']); |
||
528 | self::assertEquals($class->lifecycleCallbacks['prePersist'][1], 'doOtherStuffOnPrePersistToo'); |
||
529 | |||
530 | return $class; |
||
531 | } |
||
532 | |||
533 | /** |
||
534 | * @param ClassMetadata $class |
||
535 | * |
||
536 | * @depends testLifecycleCallbacksSupportMultipleMethodNames |
||
537 | */ |
||
538 | public function testJoinColumnUniqueAndNullable($class) : ClassMetadata |
||
539 | { |
||
540 | // Non-Nullability of Join Column |
||
541 | $association = $class->getProperty('groups'); |
||
542 | $joinTable = $association->getJoinTable(); |
||
543 | $joinColumns = $joinTable->getJoinColumns(); |
||
544 | $joinColumn = reset($joinColumns); |
||
545 | |||
546 | self::assertFalse($joinColumn->isNullable()); |
||
547 | self::assertFalse($joinColumn->isUnique()); |
||
548 | |||
549 | return $class; |
||
550 | } |
||
551 | |||
552 | /** |
||
553 | * @param ClassMetadata $class |
||
554 | * |
||
555 | * @depends testJoinColumnUniqueAndNullable |
||
556 | */ |
||
557 | public function testColumnDefinition($class) : ClassMetadata |
||
558 | { |
||
559 | self::assertNotNull($class->getProperty('email')); |
||
560 | |||
561 | $property = $class->getProperty('email'); |
||
562 | $association = $class->getProperty('groups'); |
||
563 | $joinTable = $association->getJoinTable(); |
||
564 | $inverseJoinColumns = $joinTable->getInverseJoinColumns(); |
||
565 | $inverseJoinColumn = reset($inverseJoinColumns); |
||
566 | |||
567 | self::assertEquals('CHAR(32) NOT NULL', $property->getColumnDefinition()); |
||
568 | self::assertEquals('INT NULL', $inverseJoinColumn->getColumnDefinition()); |
||
569 | |||
570 | return $class; |
||
571 | } |
||
572 | |||
573 | /** |
||
574 | * @param ClassMetadata $class |
||
575 | * |
||
576 | * @depends testColumnDefinition |
||
577 | */ |
||
578 | public function testJoinColumnOnDelete($class) : ClassMetadata |
||
579 | { |
||
580 | $association = $class->getProperty('address'); |
||
581 | $joinColumns = $association->getJoinColumns(); |
||
582 | $joinColumn = reset($joinColumns); |
||
583 | |||
584 | self::assertEquals('CASCADE', $joinColumn->getOnDelete()); |
||
585 | |||
586 | return $class; |
||
587 | } |
||
588 | |||
589 | /** |
||
590 | * @group DDC-514 |
||
591 | */ |
||
592 | public function testDiscriminatorColumnDefaults() : void |
||
593 | { |
||
594 | if (strpos(static::class, 'PHPMappingDriver') !== false) { |
||
595 | $this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
||
596 | } |
||
597 | |||
598 | $class = $this->createClassMetadata(Animal::class); |
||
599 | |||
600 | self::assertNotNull($class->discriminatorColumn); |
||
601 | |||
602 | $discrColumn = $class->discriminatorColumn; |
||
603 | |||
604 | self::assertEquals('Animal', $discrColumn->getTableName()); |
||
605 | self::assertEquals('discr', $discrColumn->getColumnName()); |
||
606 | self::assertEquals('string', $discrColumn->getTypeName()); |
||
607 | self::assertEquals(32, $discrColumn->getLength()); |
||
608 | self::assertNull($discrColumn->getColumnDefinition()); |
||
609 | } |
||
610 | |||
611 | /** |
||
612 | * @group DDC-869 |
||
613 | */ |
||
614 | public function testMappedSuperclassWithRepository() : void |
||
615 | { |
||
616 | $em = $this->getTestEntityManager(); |
||
617 | $factory = $this->createClassMetadataFactory($em); |
||
618 | $class = $factory->getMetadataFor(DDC869CreditCardPayment::class); |
||
619 | |||
620 | self::assertNotNull($class->getProperty('id')); |
||
621 | self::assertNotNull($class->getProperty('value')); |
||
622 | self::assertNotNull($class->getProperty('creditCardNumber')); |
||
623 | self::assertEquals($class->getCustomRepositoryClassName(), DDC869PaymentRepository::class); |
||
624 | self::assertInstanceOf(DDC869PaymentRepository::class, $em->getRepository(DDC869CreditCardPayment::class)); |
||
625 | self::assertTrue($em->getRepository(DDC869ChequePayment::class)->isTrue()); |
||
626 | |||
627 | $class = $factory->getMetadataFor(DDC869ChequePayment::class); |
||
628 | |||
629 | self::assertNotNull($class->getProperty('id')); |
||
630 | self::assertNotNull($class->getProperty('value')); |
||
631 | self::assertNotNull($class->getProperty('serialNumber')); |
||
632 | self::assertEquals($class->getCustomRepositoryClassName(), DDC869PaymentRepository::class); |
||
633 | self::assertInstanceOf(DDC869PaymentRepository::class, $em->getRepository(DDC869ChequePayment::class)); |
||
634 | self::assertTrue($em->getRepository(DDC869ChequePayment::class)->isTrue()); |
||
635 | } |
||
636 | |||
637 | /** |
||
638 | * @group DDC-1476 |
||
639 | */ |
||
640 | public function testDefaultFieldType() : void |
||
641 | { |
||
642 | $factory = $this->createClassMetadataFactory(); |
||
643 | $class = $factory->getMetadataFor(DDC1476EntityWithDefaultFieldType::class); |
||
644 | |||
645 | self::assertNotNull($class->getProperty('id')); |
||
646 | self::assertNotNull($class->getProperty('name')); |
||
647 | |||
648 | $idProperty = $class->getProperty('id'); |
||
649 | $nameProperty = $class->getProperty('name'); |
||
650 | |||
651 | self::assertInstanceOf(Mapping\FieldMetadata::class, $idProperty); |
||
652 | self::assertInstanceOf(Mapping\FieldMetadata::class, $nameProperty); |
||
653 | |||
654 | self::assertEquals('string', $idProperty->getTypeName()); |
||
655 | self::assertEquals('string', $nameProperty->getTypeName()); |
||
656 | |||
657 | self::assertEquals('id', $idProperty->getName()); |
||
658 | self::assertEquals('name', $nameProperty->getName()); |
||
659 | |||
660 | self::assertEquals('id', $idProperty->getColumnName()); |
||
661 | self::assertEquals('name', $nameProperty->getColumnName()); |
||
662 | |||
663 | self::assertFalse($idProperty->hasValueGenerator()); |
||
664 | } |
||
665 | |||
666 | /** |
||
667 | * @group DDC-1170 |
||
668 | */ |
||
669 | public function testIdentifierColumnDefinition() : void |
||
670 | { |
||
671 | $class = $this->createClassMetadata(DDC1170Entity::class); |
||
672 | |||
673 | self::assertNotNull($class->getProperty('id')); |
||
674 | self::assertNotNull($class->getProperty('value')); |
||
675 | |||
676 | self::assertEquals('INT unsigned NOT NULL', $class->getProperty('id')->getColumnDefinition()); |
||
677 | self::assertEquals('VARCHAR(255) NOT NULL', $class->getProperty('value')->getColumnDefinition()); |
||
678 | } |
||
679 | |||
680 | /** |
||
681 | * @group DDC-559 |
||
682 | */ |
||
683 | public function testNamingStrategy() : void |
||
684 | { |
||
685 | $em = $this->getTestEntityManager(); |
||
686 | $factory = $this->createClassMetadataFactory($em); |
||
687 | |||
688 | self::assertInstanceOf(DefaultNamingStrategy::class, $em->getConfiguration()->getNamingStrategy()); |
||
689 | $em->getConfiguration()->setNamingStrategy(new UnderscoreNamingStrategy(CASE_UPPER)); |
||
690 | self::assertInstanceOf(UnderscoreNamingStrategy::class, $em->getConfiguration()->getNamingStrategy()); |
||
691 | |||
692 | $class = $factory->getMetadataFor(DDC1476EntityWithDefaultFieldType::class); |
||
693 | $idProperty = $class->getProperty('id'); |
||
694 | $nameProperty = $class->getProperty('name'); |
||
695 | |||
696 | self::assertEquals('ID', $idProperty->getColumnName()); |
||
697 | self::assertEquals('NAME', $nameProperty->getColumnName()); |
||
698 | self::assertEquals('DDC1476ENTITY_WITH_DEFAULT_FIELD_TYPE', $class->table->getName()); |
||
699 | } |
||
700 | |||
701 | /** |
||
702 | * @group DDC-807 |
||
703 | * @group DDC-553 |
||
704 | */ |
||
705 | public function testDiscriminatorColumnDefinition() : void |
||
706 | { |
||
707 | $class = $this->createClassMetadata(DDC807Entity::class); |
||
708 | |||
709 | self::assertNotNull($class->discriminatorColumn); |
||
710 | |||
711 | $discrColumn = $class->discriminatorColumn; |
||
712 | |||
713 | self::assertEquals('dtype', $discrColumn->getColumnName()); |
||
714 | self::assertEquals("ENUM('ONE','TWO')", $discrColumn->getColumnDefinition()); |
||
715 | } |
||
716 | |||
717 | /** |
||
718 | * @group DDC-889 |
||
719 | */ |
||
720 | public function testInvalidEntityOrMappedSuperClassShouldMentionParentClasses() : void |
||
721 | { |
||
722 | $this->expectException(MappingException::class); |
||
723 | $this->expectExceptionMessage('Class "Doctrine\Tests\Models\DDC889\DDC889Class" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass" is not a valid entity or mapped super class.'); |
||
724 | |||
725 | $this->createClassMetadata(DDC889Class::class); |
||
726 | } |
||
727 | |||
728 | /** |
||
729 | * @group DDC-889 |
||
730 | */ |
||
731 | public function testIdentifierRequiredShouldMentionParentClasses() : void |
||
732 | { |
||
733 | $factory = $this->createClassMetadataFactory(); |
||
734 | |||
735 | $this->expectException(MappingException::class); |
||
736 | $this->expectExceptionMessage('No identifier/primary key specified for Entity "Doctrine\Tests\Models\DDC889\DDC889Entity" sub class of "Doctrine\Tests\Models\DDC889\DDC889SuperClass". Every Entity must have an identifier/primary key.'); |
||
737 | |||
738 | $factory->getMetadataFor(DDC889Entity::class); |
||
739 | } |
||
740 | |||
741 | /** |
||
742 | * @group DDC-964 |
||
743 | */ |
||
744 | public function testAssociationOverridesMapping() : void |
||
813 | } |
||
814 | |||
815 | /** |
||
816 | * @group DDC-3579 |
||
817 | */ |
||
818 | public function testInversedByOverrideMapping() : void |
||
819 | { |
||
820 | $factory = $this->createClassMetadataFactory(); |
||
821 | $adminMetadata = $factory->getMetadataFor(DDC3579Admin::class); |
||
822 | |||
823 | // assert groups association mappings |
||
824 | self::assertArrayHasKey('groups', iterator_to_array($adminMetadata->getPropertiesIterator())); |
||
825 | |||
826 | $adminGroups = $adminMetadata->getProperty('groups'); |
||
827 | |||
828 | // assert override |
||
829 | self::assertEquals('admins', $adminGroups->getInversedBy()); |
||
830 | } |
||
831 | |||
832 | /** |
||
833 | * @group DDC-5934 |
||
834 | */ |
||
835 | public function testFetchOverrideMapping() : void |
||
836 | { |
||
837 | // check override metadata |
||
838 | $contractMetadata = $this->createClassMetadataFactory()->getMetadataFor(DDC5934Contract::class); |
||
839 | |||
840 | self::assertArrayHasKey('members', iterator_to_array($contractMetadata->getPropertiesIterator())); |
||
841 | |||
842 | $contractMembers = $contractMetadata->getProperty('members'); |
||
843 | |||
844 | self::assertSame(Mapping\FetchMode::EXTRA_LAZY, $contractMembers->getFetchMode()); |
||
845 | } |
||
846 | |||
847 | /** |
||
848 | * @group DDC-964 |
||
849 | */ |
||
850 | public function testAttributeOverridesMapping() : void |
||
851 | { |
||
852 | $factory = $this->createClassMetadataFactory(); |
||
853 | $adminMetadata = $factory->getMetadataFor(DDC964Admin::class); |
||
854 | |||
855 | self::assertEquals( |
||
856 | [ |
||
857 | 'user_id' => 'id', |
||
858 | 'user_name' => 'name', |
||
859 | 'adminaddress_id' => 'address', |
||
860 | ], |
||
861 | $adminMetadata->fieldNames |
||
862 | ); |
||
863 | |||
864 | self::assertNotNull($adminMetadata->getProperty('id')); |
||
865 | |||
866 | $idProperty = $adminMetadata->getProperty('id'); |
||
867 | |||
868 | self::assertTrue($idProperty->isPrimaryKey()); |
||
869 | self::assertEquals('id', $idProperty->getName()); |
||
870 | self::assertEquals('user_id', $idProperty->getColumnName()); |
||
871 | |||
872 | self::assertNotNull($adminMetadata->getProperty('name')); |
||
873 | |||
874 | $nameProperty = $adminMetadata->getProperty('name'); |
||
875 | |||
876 | self::assertEquals('name', $nameProperty->getName()); |
||
877 | self::assertEquals('user_name', $nameProperty->getColumnName()); |
||
878 | self::assertEquals(250, $nameProperty->getLength()); |
||
879 | self::assertTrue($nameProperty->isNullable()); |
||
880 | self::assertFalse($nameProperty->isUnique()); |
||
881 | |||
882 | $guestMetadata = $factory->getMetadataFor(DDC964Guest::class); |
||
883 | |||
884 | self::assertEquals( |
||
885 | [ |
||
886 | 'guest_id' => 'id', |
||
887 | 'guest_name' => 'name', |
||
888 | 'address_id' => 'address', |
||
889 | ], |
||
890 | $guestMetadata->fieldNames |
||
891 | ); |
||
892 | |||
893 | self::assertNotNull($guestMetadata->getProperty('id')); |
||
894 | |||
895 | $idProperty = $guestMetadata->getProperty('id'); |
||
896 | |||
897 | self::assertTrue($idProperty->isPrimaryKey()); |
||
898 | self::assertEquals('id', $idProperty->getName()); |
||
899 | self::assertEquals('guest_id', $idProperty->getColumnName()); |
||
900 | |||
901 | self::assertNotNull($guestMetadata->getProperty('name')); |
||
902 | |||
903 | $nameProperty = $guestMetadata->getProperty('name'); |
||
904 | |||
905 | self::assertEquals('name', $nameProperty->getName()); |
||
906 | self::assertEquals('guest_name', $nameProperty->getColumnName()); |
||
907 | self::assertEquals(240, $nameProperty->getLength()); |
||
908 | self::assertFalse($nameProperty->isNullable()); |
||
909 | self::assertTrue($nameProperty->isUnique()); |
||
910 | } |
||
911 | |||
912 | /** |
||
913 | * @group DDC-1955 |
||
914 | */ |
||
915 | public function testEntityListeners() : void |
||
939 | } |
||
940 | |||
941 | /** |
||
942 | * @group DDC-1955 |
||
943 | */ |
||
944 | public function testEntityListenersOverride() : void |
||
945 | { |
||
946 | $factory = $this->createClassMetadataFactory(); |
||
947 | $ultraClass = $factory->getMetadataFor(CompanyFlexUltraContract::class); |
||
948 | |||
949 | //overridden listeners |
||
950 | self::assertArrayHasKey(Events::postPersist, $ultraClass->entityListeners); |
||
951 | self::assertArrayHasKey(Events::prePersist, $ultraClass->entityListeners); |
||
952 | |||
953 | self::assertCount(1, $ultraClass->entityListeners[Events::postPersist]); |
||
954 | self::assertCount(3, $ultraClass->entityListeners[Events::prePersist]); |
||
955 | |||
956 | $postPersist = $ultraClass->entityListeners[Events::postPersist][0]; |
||
957 | $prePersist = $ultraClass->entityListeners[Events::prePersist][0]; |
||
958 | |||
959 | self::assertEquals(CompanyContractListener::class, $postPersist['class']); |
||
960 | self::assertEquals(CompanyContractListener::class, $prePersist['class']); |
||
961 | self::assertEquals('postPersistHandler', $postPersist['method']); |
||
971 | } |
||
972 | |||
973 | /** |
||
974 | * @group DDC-2183 |
||
975 | */ |
||
976 | public function testSecondLevelCacheMapping() : void |
||
977 | { |
||
978 | $factory = $this->createClassMetadataFactory(); |
||
979 | $class = $factory->getMetadataFor(City::class); |
||
980 | |||
981 | self::assertNotNull($class->getCache()); |
||
982 | self::assertEquals(Mapping\CacheUsage::READ_ONLY, $class->getCache()->getUsage()); |
||
983 | self::assertEquals('doctrine_tests_models_cache_city', $class->getCache()->getRegion()); |
||
984 | |||
985 | self::assertArrayHasKey('state', iterator_to_array($class->getPropertiesIterator())); |
||
986 | |||
987 | $stateAssociation = $class->getProperty('state'); |
||
988 | |||
989 | self::assertNotNull($stateAssociation->getCache()); |
||
990 | self::assertEquals(Mapping\CacheUsage::READ_ONLY, $stateAssociation->getCache()->getUsage()); |
||
991 | self::assertEquals('doctrine_tests_models_cache_city__state', $stateAssociation->getCache()->getRegion()); |
||
992 | |||
993 | self::assertArrayHasKey('attractions', iterator_to_array($class->getPropertiesIterator())); |
||
994 | |||
995 | $attractionsAssociation = $class->getProperty('attractions'); |
||
996 | |||
997 | self::assertNotNull($attractionsAssociation->getCache()); |
||
998 | self::assertEquals(Mapping\CacheUsage::READ_ONLY, $attractionsAssociation->getCache()->getUsage()); |
||
999 | self::assertEquals('doctrine_tests_models_cache_city__attractions', $attractionsAssociation->getCache()->getRegion()); |
||
1000 | } |
||
1001 | |||
1002 | /** |
||
1003 | * @group DDC-2825 |
||
1004 | * @group 881 |
||
1005 | */ |
||
1006 | public function testSchemaDefinitionViaExplicitTableSchemaAnnotationProperty() : void |
||
1007 | { |
||
1008 | $factory = $this->createClassMetadataFactory(); |
||
1009 | $metadata = $factory->getMetadataFor(ExplicitSchemaAndTable::class); |
||
1010 | |||
1011 | self::assertSame('explicit_schema', $metadata->getSchemaName()); |
||
1012 | self::assertSame('explicit_table', $metadata->getTableName()); |
||
1013 | } |
||
1014 | |||
1015 | /** |
||
1016 | * @group DDC-2825 |
||
1017 | * @group 881 |
||
1018 | */ |
||
1019 | public function testSchemaDefinitionViaSchemaDefinedInTableNameInTableAnnotationProperty() : void |
||
1026 | } |
||
1027 | |||
1028 | /** |
||
1029 | * @group DDC-514 |
||
1030 | * @group DDC-1015 |
||
1031 | */ |
||
1032 | public function testDiscriminatorColumnDefaultLength() : void |
||
1033 | { |
||
1034 | if (strpos(static::class, 'PHPMappingDriver') !== false) { |
||
1035 | $this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
||
1036 | } |
||
1037 | |||
1038 | $class = $this->createClassMetadata(SingleTableEntityNoDiscriminatorColumnMapping::class); |
||
1039 | |||
1040 | self::assertEquals(255, $class->discriminatorColumn->getLength()); |
||
1041 | |||
1042 | $class = $this->createClassMetadata(SingleTableEntityIncompleteDiscriminatorColumnMapping::class); |
||
1043 | |||
1044 | self::assertEquals(255, $class->discriminatorColumn->getLength()); |
||
1045 | } |
||
1046 | |||
1047 | /** |
||
1048 | * @group DDC-514 |
||
1049 | * @group DDC-1015 |
||
1050 | */ |
||
1051 | public function testDiscriminatorColumnDefaultType() : void |
||
1064 | } |
||
1065 | |||
1066 | /** |
||
1067 | * @group DDC-514 |
||
1068 | * @group DDC-1015 |
||
1069 | */ |
||
1070 | public function testDiscriminatorColumnDefaultName() : void |
||
1071 | { |
||
1072 | if (strpos(static::class, 'PHPMappingDriver') !== false) { |
||
1073 | $this->markTestSkipped('PHP Mapping Drivers have no defaults.'); |
||
1074 | } |
||
1075 | |||
1083 | } |
||
1084 | } |
||
1085 | |||
1086 | /** |
||
1087 | * @ORM\Entity |
||
1488 |
This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces.
This is most likely a typographical error or the method has been renamed.