1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
<?php
declare(strict_types=1);
namespace Doctrine\Tests\ORM\Utility;
use Doctrine\ORM\Utility\IdentifierFlattener;
use Doctrine\Tests\Models\Cache\City;
use Doctrine\Tests\Models\Cache\Flight;
use Doctrine\Tests\Models\VersionedOneToOne\FirstRelatedEntity;
use Doctrine\Tests\Models\VersionedOneToOne\SecondRelatedEntity;
use Doctrine\Tests\OrmFunctionalTestCase;
/**
* Test the IdentifierFlattener utility class
*
* @covers \Doctrine\ORM\Utility\IdentifierFlattener
*/
class IdentifierFlattenerTest extends OrmFunctionalTestCase
{
/**
* Identifier flattener
*
* @var IdentifierFlattener
*/
private $identifierFlattener;
protected function setUp(): void
{
parent::setUp();
$this->identifierFlattener = new IdentifierFlattener(
$this->_em->getUnitOfWork(),
$this->_em->getMetadataFactory()
);
$this->createSchemaForModels(
FirstRelatedEntity::class,
SecondRelatedEntity::class,
Flight::class,
City::class
);
}
/** @group utilities */
public function testFlattenIdentifierWithOneToOneId(): void
{
$secondRelatedEntity = new SecondRelatedEntity();
$secondRelatedEntity->name = 'Bob';
$this->_em->persist($secondRelatedEntity);
$this->_em->flush();
$firstRelatedEntity = new FirstRelatedEntity();
$firstRelatedEntity->name = 'Fred';
$firstRelatedEntity->secondEntity = $secondRelatedEntity;
$this->_em->persist($firstRelatedEntity);
$this->_em->flush();
$firstEntity = $this->_em->getRepository(FirstRelatedEntity::class)
->findOneBy(['name' => 'Fred']);
$class = $this->_em->getClassMetadata(FirstRelatedEntity::class);
$id = $class->getIdentifierValues($firstEntity);
self::assertCount(1, $id, 'We should have 1 identifier');
self::assertArrayHasKey('secondEntity', $id, 'It should be called secondEntity');
self::assertInstanceOf(
'\Doctrine\Tests\Models\VersionedOneToOne\SecondRelatedEntity',
$id['secondEntity'],
'The entity should be an instance of SecondRelatedEntity'
);
$flatIds = $this->identifierFlattener->flattenIdentifier($class, $id);
self::assertCount(1, $flatIds, 'We should have 1 flattened id');
self::assertArrayHasKey('secondEntity', $flatIds, 'It should be called secondEntity');
self::assertEquals($id['secondEntity']->id, $flatIds['secondEntity']);
}
/** @group utilities */
public function testFlattenIdentifierWithMutlipleIds(): void
{
$leeds = new City('Leeds');
$london = new City('London');
$this->_em->persist($leeds);
$this->_em->persist($london);
$this->_em->flush();
$flight = new Flight($leeds, $london);
$this->_em->persist($flight);
$this->_em->flush();
$class = $this->_em->getClassMetadata(Flight::class);
$id = $class->getIdentifierValues($flight);
self::assertCount(2, $id);
self::assertArrayHasKey('leavingFrom', $id);
self::assertArrayHasKey('goingTo', $id);
self::assertEquals($leeds, $id['leavingFrom']);
self::assertEquals($london, $id['goingTo']);
$flatIds = $this->identifierFlattener->flattenIdentifier($class, $id);
self::assertCount(2, $flatIds);
self::assertArrayHasKey('leavingFrom', $flatIds);
self::assertArrayHasKey('goingTo', $flatIds);
self::assertEquals($id['leavingFrom']->getId(), $flatIds['leavingFrom']);
self::assertEquals($id['goingTo']->getId(), $flatIds['goingTo']);
}
}
|
