RelationsTest.php 19.2 KB
Newer Older
Jens Segers's avatar
Jens Segers committed
1
<?php
Simon Schaufelberger's avatar
Simon Schaufelberger committed
2
declare(strict_types=1);
Jens Segers's avatar
Jens Segers committed
3

Jens Segers's avatar
Jens Segers committed
4 5
use Illuminate\Database\Eloquent\Collection;

Jens Segers's avatar
Jens Segers committed
6 7
class RelationsTest extends TestCase
{
Stas's avatar
Stas committed
8
    public function tearDown(): void
unknown's avatar
unknown committed
9
    {
10 11
        Mockery::close();

12
        User::truncate();
Jens Segers's avatar
Jens Segers committed
13 14
        Client::truncate();
        Address::truncate();
15 16 17 18
        Book::truncate();
        Item::truncate();
        Role::truncate();
        Client::truncate();
19
        Group::truncate();
Jens Segers's avatar
Jens Segers committed
20
        Photo::truncate();
unknown's avatar
unknown committed
21 22
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
23
    public function testHasMany(): void
unknown's avatar
unknown committed
24
    {
25 26 27
        $author = User::create(['name' => 'George R. R. Martin']);
        Book::create(['title' => 'A Game of Thrones', 'author_id' => $author->_id]);
        Book::create(['title' => 'A Clash of Kings', 'author_id' => $author->_id]);
unknown's avatar
unknown committed
28

29
        $books = $author->books;
Gabriel Caruso's avatar
Gabriel Caruso committed
30
        $this->assertCount(2, $books);
unknown's avatar
unknown committed
31

32 33 34 35 36
        $user = User::create(['name' => 'John Doe']);
        Item::create(['type' => 'knife', 'user_id' => $user->_id]);
        Item::create(['type' => 'shield', 'user_id' => $user->_id]);
        Item::create(['type' => 'sword', 'user_id' => $user->_id]);
        Item::create(['type' => 'bag', 'user_id' => null]);
unknown's avatar
unknown committed
37

38
        $items = $user->items;
Gabriel Caruso's avatar
Gabriel Caruso committed
39
        $this->assertCount(3, $items);
40
    }
unknown's avatar
unknown committed
41

Simon Schaufelberger's avatar
Simon Schaufelberger committed
42
    public function testBelongsTo(): void
unknown's avatar
unknown committed
43
    {
44 45 46
        $user = User::create(['name' => 'George R. R. Martin']);
        Book::create(['title' => 'A Game of Thrones', 'author_id' => $user->_id]);
        $book = Book::create(['title' => 'A Clash of Kings', 'author_id' => $user->_id]);
unknown's avatar
unknown committed
47

48 49
        $author = $book->author;
        $this->assertEquals('George R. R. Martin', $author->name);
unknown's avatar
unknown committed
50

51 52
        $user = User::create(['name' => 'John Doe']);
        $item = Item::create(['type' => 'sword', 'user_id' => $user->_id]);
unknown's avatar
unknown committed
53

54 55
        $owner = $item->user;
        $this->assertEquals('John Doe', $owner->name);
Jens Segers's avatar
Jens Segers committed
56 57

        $book = Book::create(['title' => 'A Clash of Kings']);
Gabriel Caruso's avatar
Gabriel Caruso committed
58
        $this->assertNull($book->author);
unknown's avatar
unknown committed
59 60
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
61
    public function testHasOne(): void
unknown's avatar
unknown committed
62
    {
63 64
        $user = User::create(['name' => 'John Doe']);
        Role::create(['type' => 'admin', 'user_id' => $user->_id]);
unknown's avatar
unknown committed
65

66 67
        $role = $user->role;
        $this->assertEquals('admin', $role->type);
Jens Segers's avatar
Jens Segers committed
68 69
        $this->assertEquals($user->_id, $role->user_id);

70 71
        $user = User::create(['name' => 'Jane Doe']);
        $role = new Role(['type' => 'user']);
Jens Segers's avatar
Jens Segers committed
72 73 74 75 76 77 78 79 80 81
        $user->role()->save($role);

        $role = $user->role;
        $this->assertEquals('user', $role->type);
        $this->assertEquals($user->_id, $role->user_id);

        $user = User::where('name', 'Jane Doe')->first();
        $role = $user->role;
        $this->assertEquals('user', $role->type);
        $this->assertEquals($user->_id, $role->user_id);
unknown's avatar
unknown committed
82 83
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
84
    public function testWithBelongsTo(): void
unknown's avatar
unknown committed
85
    {
86 87 88 89 90
        $user = User::create(['name' => 'John Doe']);
        Item::create(['type' => 'knife', 'user_id' => $user->_id]);
        Item::create(['type' => 'shield', 'user_id' => $user->_id]);
        Item::create(['type' => 'sword', 'user_id' => $user->_id]);
        Item::create(['type' => 'bag', 'user_id' => null]);
91

Alexandre Butynski's avatar
Alexandre Butynski committed
92
        $items = Item::with('user')->orderBy('user_id', 'desc')->get();
93 94

        $user = $items[0]->getRelation('user');
Jens Segers's avatar
Jens Segers committed
95
        $this->assertInstanceOf(User::class, $user);
96
        $this->assertEquals('John Doe', $user->name);
Gabriel Caruso's avatar
Gabriel Caruso committed
97 98
        $this->assertCount(1, $items[0]->getRelations());
        $this->assertNull($items[3]->getRelation('user'));
unknown's avatar
unknown committed
99 100
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
101
    public function testWithHashMany(): void
unknown's avatar
unknown committed
102
    {
103 104 105 106 107
        $user = User::create(['name' => 'John Doe']);
        Item::create(['type' => 'knife', 'user_id' => $user->_id]);
        Item::create(['type' => 'shield', 'user_id' => $user->_id]);
        Item::create(['type' => 'sword', 'user_id' => $user->_id]);
        Item::create(['type' => 'bag', 'user_id' => null]);
unknown's avatar
unknown committed
108

109
        $user = User::with('items')->find($user->_id);
unknown's avatar
unknown committed
110

111
        $items = $user->getRelation('items');
Gabriel Caruso's avatar
Gabriel Caruso committed
112
        $this->assertCount(3, $items);
Jens Segers's avatar
Jens Segers committed
113
        $this->assertInstanceOf(Item::class, $items[0]);
unknown's avatar
unknown committed
114 115
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
116
    public function testWithHasOne(): void
unknown's avatar
unknown committed
117
    {
118 119 120
        $user = User::create(['name' => 'John Doe']);
        Role::create(['type' => 'admin', 'user_id' => $user->_id]);
        Role::create(['type' => 'guest', 'user_id' => $user->_id]);
unknown's avatar
unknown committed
121

122
        $user = User::with('role')->find($user->_id);
unknown's avatar
unknown committed
123

124
        $role = $user->getRelation('role');
Jens Segers's avatar
Jens Segers committed
125
        $this->assertInstanceOf(Role::class, $role);
126
        $this->assertEquals('admin', $role->type);
unknown's avatar
unknown committed
127 128
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
129
    public function testEasyRelation(): void
unknown's avatar
unknown committed
130
    {
131
        // Has Many
132 133
        $user = User::create(['name' => 'John Doe']);
        $item = Item::create(['type' => 'knife']);
134 135 136 137
        $user->items()->save($item);

        $user = User::find($user->_id);
        $items = $user->items;
Gabriel Caruso's avatar
Gabriel Caruso committed
138
        $this->assertCount(1, $items);
Jens Segers's avatar
Jens Segers committed
139
        $this->assertInstanceOf(Item::class, $items[0]);
Jens Segers's avatar
Jens Segers committed
140
        $this->assertEquals($user->_id, $items[0]->user_id);
141 142

        // Has one
143 144
        $user = User::create(['name' => 'John Doe']);
        $role = Role::create(['type' => 'admin']);
145 146 147 148
        $user->role()->save($role);

        $user = User::find($user->_id);
        $role = $user->role;
Jens Segers's avatar
Jens Segers committed
149
        $this->assertInstanceOf(Role::class, $role);
150
        $this->assertEquals('admin', $role->type);
Jens Segers's avatar
Jens Segers committed
151
        $this->assertEquals($user->_id, $role->user_id);
152 153
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
154
    public function testBelongsToMany(): void
155
    {
156
        $user = User::create(['name' => 'John Doe']);
157

158
        // Add 2 clients
159 160
        $user->clients()->save(new Client(['name' => 'Pork Pies Ltd.']));
        $user->clients()->create(['name' => 'Buffet Bar Inc.']);
161

162
        // Refetch
163 164 165
        $user = User::with('clients')->find($user->_id);
        $client = Client::with('users')->first();

166
        // Check for relation attributes
Gabriel Caruso's avatar
Gabriel Caruso committed
167 168
        $this->assertArrayHasKey('user_ids', $client->getAttributes());
        $this->assertArrayHasKey('client_ids', $user->getAttributes());
169

170
        $clients = $user->getRelation('clients');
171
        $users = $client->getRelation('users');
172

Jens Segers's avatar
Jens Segers committed
173 174 175 176
        $this->assertInstanceOf(Collection::class, $users);
        $this->assertInstanceOf(Collection::class, $clients);
        $this->assertInstanceOf(Client::class, $clients[0]);
        $this->assertInstanceOf(User::class, $users[0]);
177 178 179 180
        $this->assertCount(2, $user->clients);
        $this->assertCount(1, $client->users);

        // Now create a new user to an existing client
181
        $user = $client->users()->create(['name' => 'Jane Doe']);
182

Jens Segers's avatar
Jens Segers committed
183 184
        $this->assertInstanceOf(Collection::class, $user->clients);
        $this->assertInstanceOf(Client::class, $user->clients->first());
Jens Segers's avatar
Jens Segers committed
185
        $this->assertCount(1, $user->clients);
186

Jens Segers's avatar
Jens Segers committed
187
        // Get user and unattached client
188 189 190 191
        $user = User::where('name', '=', 'Jane Doe')->first();
        $client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();

        // Check the models are what they should be
Jens Segers's avatar
Jens Segers committed
192 193
        $this->assertInstanceOf(Client::class, $client);
        $this->assertInstanceOf(User::class, $user);
194 195

        // Assert they are not attached
Gabriel Caruso's avatar
Gabriel Caruso committed
196 197
        $this->assertNotContains($client->_id, $user->client_ids);
        $this->assertNotContains($user->_id, $client->user_ids);
Jens Segers's avatar
Jens Segers committed
198 199
        $this->assertCount(1, $user->clients);
        $this->assertCount(1, $client->users);
200 201 202 203 204 205 206 207 208

        // Attach the client to the user
        $user->clients()->attach($client);

        // Get the new user model
        $user = User::where('name', '=', 'Jane Doe')->first();
        $client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();

        // Assert they are attached
Gabriel Caruso's avatar
Gabriel Caruso committed
209 210
        $this->assertContains($client->_id, $user->client_ids);
        $this->assertContains($user->_id, $client->user_ids);
Jens Segers's avatar
Jens Segers committed
211 212 213 214
        $this->assertCount(2, $user->clients);
        $this->assertCount(2, $client->users);

        // Detach clients from user
215
        $user->clients()->sync([]);
Jens Segers's avatar
Jens Segers committed
216 217 218 219 220 221

        // Get the new user model
        $user = User::where('name', '=', 'Jane Doe')->first();
        $client = Client::Where('name', '=', 'Buffet Bar Inc.')->first();

        // Assert they are not attached
Gabriel Caruso's avatar
Gabriel Caruso committed
222 223
        $this->assertNotContains($client->_id, $user->client_ids);
        $this->assertNotContains($user->_id, $client->user_ids);
Jens Segers's avatar
Jens Segers committed
224 225
        $this->assertCount(0, $user->clients);
        $this->assertCount(1, $client->users);
226 227
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
228
    public function testBelongsToManyAttachesExistingModels(): void
229
    {
230
        $user = User::create(['name' => 'John Doe', 'client_ids' => ['1234523']]);
231

232 233
        $clients = [
            Client::create(['name' => 'Pork Pies Ltd.'])->_id,
Jens Segers's avatar
Jens Segers committed
234
            Client::create(['name' => 'Buffet Bar Inc.'])->_id,
235
        ];
236

237 238
        $moreClients = [
            Client::create(['name' => 'synced Boloni Ltd.'])->_id,
Jens Segers's avatar
Jens Segers committed
239
            Client::create(['name' => 'synced Meatballs Inc.'])->_id,
240
        ];
241 242 243 244 245 246 247

        // Sync multiple records
        $user->clients()->sync($clients);

        $user = User::with('clients')->find($user->_id);

        // Assert non attached ID's are detached succesfully
Gabriel Caruso's avatar
Gabriel Caruso committed
248
        $this->assertNotContains('1234523', $user->client_ids);
249 250 251 252

        // Assert there are two client objects in the relationship
        $this->assertCount(2, $user->clients);

Jens Segers's avatar
Jens Segers committed
253
        // Add more clients
254 255
        $user->clients()->sync($moreClients);

256
        // Refetch
257 258
        $user = User::with('clients')->find($user->_id);

unknown's avatar
unknown committed
259 260
        // Assert there are now still 2 client objects in the relationship
        $this->assertCount(2, $user->clients);
261 262 263 264 265 266

        // Assert that the new relationships name start with synced
        $this->assertStringStartsWith('synced', $user->clients[0]->name);
        $this->assertStringStartsWith('synced', $user->clients[1]->name);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
267
    public function testBelongsToManySync(): void
Jens Segers's avatar
Jens Segers committed
268 269
    {
        // create test instances
270 271 272
        $user = User::create(['name' => 'John Doe']);
        $client1 = Client::create(['name' => 'Pork Pies Ltd.'])->_id;
        $client2 = Client::create(['name' => 'Buffet Bar Inc.'])->_id;
Jens Segers's avatar
Jens Segers committed
273 274

        // Sync multiple
275
        $user->clients()->sync([$client1, $client2]);
Jens Segers's avatar
Jens Segers committed
276 277 278 279 280 281
        $this->assertCount(2, $user->clients);

        // Refresh user
        $user = User::where('name', '=', 'John Doe')->first();

        // Sync single
282
        $user->clients()->sync([$client1]);
Jens Segers's avatar
Jens Segers committed
283 284 285
        $this->assertCount(1, $user->clients);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
286
    public function testBelongsToManyAttachArray(): void
Jens Segers's avatar
Jens Segers committed
287
    {
288 289 290
        $user = User::create(['name' => 'John Doe']);
        $client1 = Client::create(['name' => 'Test 1'])->_id;
        $client2 = Client::create(['name' => 'Test 2'])->_id;
Jens Segers's avatar
Jens Segers committed
291 292 293 294 295 296

        $user = User::where('name', '=', 'John Doe')->first();
        $user->clients()->attach([$client1, $client2]);
        $this->assertCount(2, $user->clients);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
297
    public function testBelongsToManyAttachEloquentCollection(): void
298 299 300 301 302 303 304 305 306 307 308
    {
        $user = User::create(['name' => 'John Doe']);
        $client1 = Client::create(['name' => 'Test 1']);
        $client2 = Client::create(['name' => 'Test 2']);
        $collection = new \Illuminate\Database\Eloquent\Collection([$client1, $client2]);

        $user = User::where('name', '=', 'John Doe')->first();
        $user->clients()->attach($collection);
        $this->assertCount(2, $user->clients);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
309
    public function testBelongsToManySyncAlreadyPresent(): void
Jens Segers's avatar
Jens Segers committed
310
    {
311 312 313
        $user = User::create(['name' => 'John Doe']);
        $client1 = Client::create(['name' => 'Test 1'])->_id;
        $client2 = Client::create(['name' => 'Test 2'])->_id;
Jens Segers's avatar
Jens Segers committed
314 315 316 317 318 319 320 321 322 323 324 325

        $user->clients()->sync([$client1, $client2]);
        $this->assertCount(2, $user->clients);

        $user = User::where('name', '=', 'John Doe')->first();
        $user->clients()->sync([$client1]);
        $this->assertCount(1, $user->clients);

        $user = User::where('name', '=', 'John Doe')->first()->toArray();
        $this->assertCount(1, $user['client_ids']);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
326
    public function testBelongsToManyCustom(): void
327
    {
328 329
        $user = User::create(['name' => 'John Doe']);
        $group = $user->groups()->create(['name' => 'Admins']);
330 331 332 333 334 335

        // Refetch
        $user = User::find($user->_id);
        $group = Group::find($group->_id);

        // Check for custom relation attributes
Gabriel Caruso's avatar
Gabriel Caruso committed
336 337
        $this->assertArrayHasKey('users', $group->getAttributes());
        $this->assertArrayHasKey('groups', $user->getAttributes());
338 339

        // Assert they are attached
Gabriel Caruso's avatar
Gabriel Caruso committed
340 341
        $this->assertContains($group->_id, $user->groups->pluck('_id')->toArray());
        $this->assertContains($user->_id, $group->users->pluck('_id')->toArray());
342 343
        $this->assertEquals($group->_id, $user->groups()->first()->_id);
        $this->assertEquals($user->_id, $group->users()->first()->_id);
unknown's avatar
unknown committed
344
    }
Jens Segers's avatar
Jens Segers committed
345

Simon Schaufelberger's avatar
Simon Schaufelberger committed
346
    public function testMorph(): void
Jens Segers's avatar
Jens Segers committed
347
    {
348 349
        $user = User::create(['name' => 'John Doe']);
        $client = Client::create(['name' => 'Jane Doe']);
Jens Segers's avatar
Jens Segers committed
350

351
        $photo = Photo::create(['url' => 'http://graph.facebook.com/john.doe/picture']);
352 353
        $photo = $user->photos()->save($photo);

Jens Segers's avatar
Jens Segers committed
354 355 356
        $this->assertEquals(1, $user->photos->count());
        $this->assertEquals($photo->id, $user->photos->first()->id);

Jens Segers's avatar
Jens Segers committed
357 358 359 360
        $user = User::find($user->_id);
        $this->assertEquals(1, $user->photos->count());
        $this->assertEquals($photo->id, $user->photos->first()->id);

361
        $photo = Photo::create(['url' => 'http://graph.facebook.com/jane.doe/picture']);
Jens Segers's avatar
Jens Segers committed
362
        $client->photo()->save($photo);
Jens Segers's avatar
Jens Segers committed
363

Jens Segers's avatar
Jens Segers committed
364 365
        $this->assertNotNull($client->photo);
        $this->assertEquals($photo->id, $client->photo->id);
Jens Segers's avatar
Jens Segers committed
366 367

        $client = Client::find($client->_id);
Jens Segers's avatar
Jens Segers committed
368 369
        $this->assertNotNull($client->photo);
        $this->assertEquals($photo->id, $client->photo->id);
Jens Segers's avatar
Jens Segers committed
370 371 372

        $photo = Photo::first();
        $this->assertEquals($photo->imageable->name, $user->name);
Jens Segers's avatar
Jens Segers committed
373 374 375

        $user = User::with('photos')->find($user->_id);
        $relations = $user->getRelations();
Gabriel Caruso's avatar
Gabriel Caruso committed
376
        $this->assertArrayHasKey('photos', $relations);
Jens Segers's avatar
Jens Segers committed
377
        $this->assertEquals(1, $relations['photos']->count());
378 379 380

        $photos = Photo::with('imageable')->get();
        $relations = $photos[0]->getRelations();
Gabriel Caruso's avatar
Gabriel Caruso committed
381
        $this->assertArrayHasKey('imageable', $relations);
Jens Segers's avatar
Jens Segers committed
382
        $this->assertInstanceOf(User::class, $photos[0]->imageable);
383 384

        $relations = $photos[1]->getRelations();
Gabriel Caruso's avatar
Gabriel Caruso committed
385
        $this->assertArrayHasKey('imageable', $relations);
Jens Segers's avatar
Jens Segers committed
386
        $this->assertInstanceOf(Client::class, $photos[1]->imageable);
387
    }
388

Simon Schaufelberger's avatar
Simon Schaufelberger committed
389
    public function testHasManyHas(): void
390
    {
391 392 393 394 395 396 397
        $author1 = User::create(['name' => 'George R. R. Martin']);
        $author1->books()->create(['title' => 'A Game of Thrones', 'rating' => 5]);
        $author1->books()->create(['title' => 'A Clash of Kings', 'rating' => 5]);
        $author2 = User::create(['name' => 'John Doe']);
        $author2->books()->create(['title' => 'My book', 'rating' => 2]);
        User::create(['name' => 'Anonymous author']);
        Book::create(['title' => 'Anonymous book', 'rating' => 1]);
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

        $authors = User::has('books')->get();
        $this->assertCount(2, $authors);
        $this->assertEquals('George R. R. Martin', $authors[0]->name);
        $this->assertEquals('John Doe', $authors[1]->name);

        $authors = User::has('books', '>', 1)->get();
        $this->assertCount(1, $authors);

        $authors = User::has('books', '<', 5)->get();
        $this->assertCount(3, $authors);

        $authors = User::has('books', '>=', 2)->get();
        $this->assertCount(1, $authors);

        $authors = User::has('books', '<=', 1)->get();
        $this->assertCount(2, $authors);

        $authors = User::has('books', '=', 2)->get();
        $this->assertCount(1, $authors);

        $authors = User::has('books', '!=', 2)->get();
        $this->assertCount(2, $authors);

        $authors = User::has('books', '=', 0)->get();
        $this->assertCount(1, $authors);

        $authors = User::has('books', '!=', 0)->get();
        $this->assertCount(2, $authors);

Jens Segers's avatar
Jens Segers committed
428
        $authors = User::whereHas('books', function ($query) {
429 430 431 432
            $query->where('rating', 5);
        })->get();
        $this->assertCount(1, $authors);

Jens Segers's avatar
Jens Segers committed
433
        $authors = User::whereHas('books', function ($query) {
434 435 436 437 438
            $query->where('rating', '<', 5);
        })->get();
        $this->assertCount(1, $authors);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
439
    public function testHasOneHas(): void
440
    {
441 442 443 444 445 446
        $user1 = User::create(['name' => 'John Doe']);
        $user1->role()->create(['title' => 'admin']);
        $user2 = User::create(['name' => 'Jane Doe']);
        $user2->role()->create(['title' => 'reseller']);
        User::create(['name' => 'Mark Moe']);
        Role::create(['title' => 'Customer']);
447 448

        $users = User::has('role')->get();
449

450 451 452 453 454 455 456 457 458 459 460
        $this->assertCount(2, $users);
        $this->assertEquals('John Doe', $users[0]->name);
        $this->assertEquals('Jane Doe', $users[1]->name);

        $users = User::has('role', '=', 0)->get();
        $this->assertCount(1, $users);

        $users = User::has('role', '!=', 0)->get();
        $this->assertCount(2, $users);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
461
    public function testNestedKeys(): void
Jens Segers's avatar
Jens Segers committed
462
    {
463 464
        $client = Client::create([
            'data' => [
Jens Segers's avatar
Jens Segers committed
465
                'client_id' => 35298,
Jens Segers's avatar
Jens Segers committed
466
                'name' => 'John Doe',
Jens Segers's avatar
Jens Segers committed
467
            ],
468
        ]);
Jens Segers's avatar
Jens Segers committed
469

470 471
        $address = $client->addresses()->create([
            'data' => [
Jens Segers's avatar
Jens Segers committed
472
                'address_id' => 1432,
Jens Segers's avatar
Jens Segers committed
473
                'city' => 'Paris',
Jens Segers's avatar
Jens Segers committed
474
            ],
475
        ]);
Jens Segers's avatar
Jens Segers committed
476 477 478 479 480 481

        $client = Client::where('data.client_id', 35298)->first();
        $this->assertEquals(1, $client->addresses->count());

        $address = $client->addresses->first();
        $this->assertEquals('Paris', $address->data['city']);
Jens Segers's avatar
Jens Segers committed
482 483 484

        $client = Client::with('addresses')->first();
        $this->assertEquals('Paris', $client->addresses->first()->data['city']);
Jens Segers's avatar
Jens Segers committed
485 486
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
487
    public function testDoubleSaveOneToMany(): void
Jens Segers's avatar
Jens Segers committed
488
    {
489 490
        $author = User::create(['name' => 'George R. R. Martin']);
        $book = Book::create(['title' => 'A Game of Thrones']);
Jens Segers's avatar
Jens Segers committed
491 492 493 494 495

        $author->books()->save($book);
        $author->books()->save($book);
        $author->save();
        $this->assertEquals(1, $author->books()->count());
496
        $this->assertEquals($author->_id, $book->author_id);
Jens Segers's avatar
Jens Segers committed
497 498

        $author = User::where('name', 'George R. R. Martin')->first();
499
        $book = Book::where('title', 'A Game of Thrones')->first();
Jens Segers's avatar
Jens Segers committed
500
        $this->assertEquals(1, $author->books()->count());
501
        $this->assertEquals($author->_id, $book->author_id);
Jens Segers's avatar
Jens Segers committed
502 503 504 505 506

        $author->books()->save($book);
        $author->books()->save($book);
        $author->save();
        $this->assertEquals(1, $author->books()->count());
507 508 509
        $this->assertEquals($author->_id, $book->author_id);
    }

Simon Schaufelberger's avatar
Simon Schaufelberger committed
510
    public function testDoubleSaveManyToMany(): void
511
    {
512 513
        $user = User::create(['name' => 'John Doe']);
        $client = Client::create(['name' => 'Admins']);
514 515 516 517 518 519

        $user->clients()->save($client);
        $user->clients()->save($client);
        $user->save();

        $this->assertEquals(1, $user->clients()->count());
520 521
        $this->assertEquals([$user->_id], $client->user_ids);
        $this->assertEquals([$client->_id], $user->client_ids);
522 523 524 525

        $user = User::where('name', 'John Doe')->first();
        $client = Client::where('name', 'Admins')->first();
        $this->assertEquals(1, $user->clients()->count());
526 527
        $this->assertEquals([$user->_id], $client->user_ids);
        $this->assertEquals([$client->_id], $user->client_ids);
528 529 530 531 532

        $user->clients()->save($client);
        $user->clients()->save($client);
        $user->save();
        $this->assertEquals(1, $user->clients()->count());
533 534
        $this->assertEquals([$user->_id], $client->user_ids);
        $this->assertEquals([$client->_id], $user->client_ids);
Jens Segers's avatar
Jens Segers committed
535
    }
536
}