ActiveRecordTestTrait.php 43.1 KB
Newer Older
1 2
<?php
/**
3 4
 *
 *
5 6 7 8 9
 * @author Carsten Brandt <mail@cebe.cc>
 */

namespace yiiunit\framework\ar;

10
use yii\base\Event;
11
use yii\db\ActiveQueryInterface;
12
use yii\db\BaseActiveRecord;
13 14 15 16 17
use yiiunit\TestCase;
use yiiunit\data\ar\Customer;
use yiiunit\data\ar\Order;

/**
Qiang Xue committed
18
 * This trait provides unit tests shared by the different AR implementations
19 20 21 22 23
 *
 * @var TestCase $this
 */
trait ActiveRecordTestTrait
{
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
    /**
     * This method should return the classname of Customer class
     * @return string
     */
    abstract public function getCustomerClass();

    /**
     * This method should return the classname of Order class
     * @return string
     */
    abstract public function getOrderClass();

    /**
     * This method should return the classname of OrderItem class
     * @return string
     */
    abstract public function getOrderItemClass();

    /**
     * This method should return the classname of Item class
     * @return string
     */
    abstract public function getItemClass();

48 49 50 51
    abstract public function getOrderWithNullFKClass();

    abstract public function getOrderItemWithNullFKmClass();

52 53 54 55 56 57 58 59 60
    /**
     * can be overridden to do things after save()
     */
    public function afterSave()
    {
    }

    public function testFind()
    {
Qiang Xue committed
61
        /** @var \yii\db\ActiveRecordInterface $customerClass */
62 63 64
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // find one
Qiang Xue committed
65
        $result = $customerClass::find();
66 67 68 69 70
        $this->assertTrue($result instanceof ActiveQueryInterface);
        $customer = $result->one();
        $this->assertTrue($customer instanceof $customerClass);

        // find all
Qiang Xue committed
71
        $customers = $customerClass::find()->all();
72 73 74 75 76 77
        $this->assertEquals(3, count($customers));
        $this->assertTrue($customers[0] instanceof $customerClass);
        $this->assertTrue($customers[1] instanceof $customerClass);
        $this->assertTrue($customers[2] instanceof $customerClass);

        // find by a single primary key
Alexander Makarov committed
78
        $customer = $customerClass::findOne(2);
79 80
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals('user2', $customer->name);
Alexander Makarov committed
81
        $customer = $customerClass::findOne(5);
82
        $this->assertNull($customer);
Alexander Makarov committed
83
        $customer = $customerClass::findOne(['id' => [5, 6, 1]]);
84
        $this->assertEquals(1, count($customer));
Qiang Xue committed
85
        $customer = $customerClass::find()->where(['id' => [5, 6, 1]])->one();
86 87 88
        $this->assertNotNull($customer);

        // find by column values
Alexander Makarov committed
89
        $customer = $customerClass::findOne(['id' => 2, 'name' => 'user2']);
90 91
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals('user2', $customer->name);
Alexander Makarov committed
92
        $customer = $customerClass::findOne(['id' => 2, 'name' => 'user1']);
93
        $this->assertNull($customer);
Alexander Makarov committed
94
        $customer = $customerClass::findOne(['id' => 5]);
95
        $this->assertNull($customer);
Alexander Makarov committed
96
        $customer = $customerClass::findOne(['name' => 'user5']);
97 98 99
        $this->assertNull($customer);

        // find by attributes
Qiang Xue committed
100
        $customer = $customerClass::find()->where(['name' => 'user2'])->one();
101 102 103 104
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals(2, $customer->id);

        // scope
Qiang Xue committed
105 106
        $this->assertEquals(2, count($customerClass::find()->active()->all()));
        $this->assertEquals(2, $customerClass::find()->active()->count());
107 108 109 110
    }

    public function testFindAsArray()
    {
Qiang Xue committed
111 112 113
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

114
        // asArray
Qiang Xue committed
115
        $customer = $customerClass::find()->where(['id' => 2])->asArray()->one();
116 117 118 119 120 121 122 123
        $this->assertEquals([
            'id' => 2,
            'email' => 'user2@example.com',
            'name' => 'user2',
            'address' => 'address2',
            'status' => 1,
            'profile_id' => null,
        ], $customer);
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

        // find all asArray
        $customers = $customerClass::find()->asArray()->all();
        $this->assertEquals(3, count($customers));
        $this->assertArrayHasKey('id', $customers[0]);
        $this->assertArrayHasKey('name', $customers[0]);
        $this->assertArrayHasKey('email', $customers[0]);
        $this->assertArrayHasKey('address', $customers[0]);
        $this->assertArrayHasKey('status', $customers[0]);
        $this->assertArrayHasKey('id', $customers[1]);
        $this->assertArrayHasKey('name', $customers[1]);
        $this->assertArrayHasKey('email', $customers[1]);
        $this->assertArrayHasKey('address', $customers[1]);
        $this->assertArrayHasKey('status', $customers[1]);
        $this->assertArrayHasKey('id', $customers[2]);
        $this->assertArrayHasKey('name', $customers[2]);
        $this->assertArrayHasKey('email', $customers[2]);
        $this->assertArrayHasKey('address', $customers[2]);
        $this->assertArrayHasKey('status', $customers[2]);
143 144 145 146
    }

    public function testFindScalar()
    {
Qiang Xue committed
147 148 149
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

150 151
        /** @var TestCase|ActiveRecordTestTrait $this */
        // query scalar
Qiang Xue committed
152
        $customerName = $customerClass::find()->where(['id' => 2])->scalar('name');
153
        $this->assertEquals('user2', $customerName);
Qiang Xue committed
154
        $customerName = $customerClass::find()->where(['status' => 2])->scalar('name');
155
        $this->assertEquals('user3', $customerName);
Qiang Xue committed
156
        $customerName = $customerClass::find()->where(['status' => 2])->scalar('noname');
157
        $this->assertNull($customerName);
Qiang Xue committed
158
        $customerId = $customerClass::find()->where(['status' => 2])->scalar('id');
159 160 161 162 163
        $this->assertEquals(3, $customerId);
    }

    public function testFindColumn()
    {
Qiang Xue committed
164 165 166
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

167
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
168 169
        $this->assertEquals(['user1', 'user2', 'user3'], $customerClass::find()->orderBy(['name' => SORT_ASC])->column('name'));
        $this->assertEquals(['user3', 'user2', 'user1'], $customerClass::find()->orderBy(['name' => SORT_DESC])->column('name'));
170 171 172 173
    }

    public function testFindIndexBy()
    {
Qiang Xue committed
174
        /** @var \yii\db\ActiveRecordInterface $customerClass */
175 176 177
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // indexBy
Qiang Xue committed
178
        $customers = $customerClass::find()->indexBy('name')->orderBy('id')->all();
179 180 181 182 183 184
        $this->assertEquals(3, count($customers));
        $this->assertTrue($customers['user1'] instanceof $customerClass);
        $this->assertTrue($customers['user2'] instanceof $customerClass);
        $this->assertTrue($customers['user3'] instanceof $customerClass);

        // indexBy callable
Qiang Xue committed
185
        $customers = $customerClass::find()->indexBy(function ($customer) {
186 187 188 189 190 191 192 193 194 195
            return $customer->id . '-' . $customer->name;
        })->orderBy('id')->all();
        $this->assertEquals(3, count($customers));
        $this->assertTrue($customers['1-user1'] instanceof $customerClass);
        $this->assertTrue($customers['2-user2'] instanceof $customerClass);
        $this->assertTrue($customers['3-user3'] instanceof $customerClass);
    }

    public function testFindIndexByAsArray()
    {
Qiang Xue committed
196 197 198
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

199 200
        /** @var TestCase|ActiveRecordTestTrait $this */
        // indexBy + asArray
Qiang Xue committed
201
        $customers = $customerClass::find()->asArray()->indexBy('name')->all();
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
        $this->assertEquals(3, count($customers));
        $this->assertArrayHasKey('id', $customers['user1']);
        $this->assertArrayHasKey('name', $customers['user1']);
        $this->assertArrayHasKey('email', $customers['user1']);
        $this->assertArrayHasKey('address', $customers['user1']);
        $this->assertArrayHasKey('status', $customers['user1']);
        $this->assertArrayHasKey('id', $customers['user2']);
        $this->assertArrayHasKey('name', $customers['user2']);
        $this->assertArrayHasKey('email', $customers['user2']);
        $this->assertArrayHasKey('address', $customers['user2']);
        $this->assertArrayHasKey('status', $customers['user2']);
        $this->assertArrayHasKey('id', $customers['user3']);
        $this->assertArrayHasKey('name', $customers['user3']);
        $this->assertArrayHasKey('email', $customers['user3']);
        $this->assertArrayHasKey('address', $customers['user3']);
        $this->assertArrayHasKey('status', $customers['user3']);

        // indexBy callable + asArray
Qiang Xue committed
220
        $customers = $customerClass::find()->indexBy(function ($customer) {
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
            return $customer['id'] . '-' . $customer['name'];
        })->asArray()->all();
        $this->assertEquals(3, count($customers));
        $this->assertArrayHasKey('id', $customers['1-user1']);
        $this->assertArrayHasKey('name', $customers['1-user1']);
        $this->assertArrayHasKey('email', $customers['1-user1']);
        $this->assertArrayHasKey('address', $customers['1-user1']);
        $this->assertArrayHasKey('status', $customers['1-user1']);
        $this->assertArrayHasKey('id', $customers['2-user2']);
        $this->assertArrayHasKey('name', $customers['2-user2']);
        $this->assertArrayHasKey('email', $customers['2-user2']);
        $this->assertArrayHasKey('address', $customers['2-user2']);
        $this->assertArrayHasKey('status', $customers['2-user2']);
        $this->assertArrayHasKey('id', $customers['3-user3']);
        $this->assertArrayHasKey('name', $customers['3-user3']);
        $this->assertArrayHasKey('email', $customers['3-user3']);
        $this->assertArrayHasKey('address', $customers['3-user3']);
        $this->assertArrayHasKey('status', $customers['3-user3']);
    }

    public function testRefresh()
    {
Qiang Xue committed
243
        /** @var \yii\db\ActiveRecordInterface $customerClass */
244 245 246 247 248
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        $customer = new $customerClass();
        $this->assertFalse($customer->refresh());

Alexander Makarov committed
249
        $customer = $customerClass::findOne(1);
250 251 252 253 254 255 256
        $customer->name = 'to be refreshed';
        $this->assertTrue($customer->refresh());
        $this->assertEquals('user1', $customer->name);
    }

    public function testEquals()
    {
Qiang Xue committed
257
        /** @var \yii\db\ActiveRecordInterface $customerClass */
258
        $customerClass = $this->getCustomerClass();
Qiang Xue committed
259
        /** @var \yii\db\ActiveRecordInterface $itemClass */
260 261 262 263 264 265 266 267 268 269 270
        $itemClass = $this->getItemClass();

        /** @var TestCase|ActiveRecordTestTrait $this */
        $customerA = new $customerClass();
        $customerB = new $customerClass();
        $this->assertFalse($customerA->equals($customerB));

        $customerA = new $customerClass();
        $customerB = new $itemClass();
        $this->assertFalse($customerA->equals($customerB));

Alexander Makarov committed
271 272
        $customerA = $customerClass::findOne(1);
        $customerB = $customerClass::findOne(2);
273 274
        $this->assertFalse($customerA->equals($customerB));

Alexander Makarov committed
275
        $customerB = $customerClass::findOne(1);
276 277
        $this->assertTrue($customerA->equals($customerB));

Alexander Makarov committed
278 279
        $customerA = $customerClass::findOne(1);
        $customerB = $itemClass::findOne(1);
280 281 282 283 284
        $this->assertFalse($customerA->equals($customerB));
    }

    public function testFindCount()
    {
Qiang Xue committed
285 286 287
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

288
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
289
        $this->assertEquals(3, $customerClass::find()->count());
290

Qiang Xue committed
291 292 293 294
        $this->assertEquals(1, $customerClass::find()->where(['id' => 1])->count());
        $this->assertEquals(2, $customerClass::find()->where(['id' => [1, 2]])->count());
        $this->assertEquals(2, $customerClass::find()->where(['id' => [1, 2]])->offset(1)->count());
        $this->assertEquals(2, $customerClass::find()->where(['id' => [1, 2]])->offset(2)->count());
295 296

        // limit should have no effect on count()
Qiang Xue committed
297 298 299 300
        $this->assertEquals(3, $customerClass::find()->limit(1)->count());
        $this->assertEquals(3, $customerClass::find()->limit(2)->count());
        $this->assertEquals(3, $customerClass::find()->limit(10)->count());
        $this->assertEquals(3, $customerClass::find()->offset(2)->limit(2)->count());
301 302 303 304
    }

    public function testFindLimit()
    {
Qiang Xue committed
305 306 307
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

308 309
        /** @var TestCase|ActiveRecordTestTrait $this */
        // all()
Qiang Xue committed
310
        $customers = $customerClass::find()->all();
311 312
        $this->assertEquals(3, count($customers));

Qiang Xue committed
313
        $customers = $customerClass::find()->orderBy('id')->limit(1)->all();
314 315 316
        $this->assertEquals(1, count($customers));
        $this->assertEquals('user1', $customers[0]->name);

Qiang Xue committed
317
        $customers = $customerClass::find()->orderBy('id')->limit(1)->offset(1)->all();
318 319 320
        $this->assertEquals(1, count($customers));
        $this->assertEquals('user2', $customers[0]->name);

Qiang Xue committed
321
        $customers = $customerClass::find()->orderBy('id')->limit(1)->offset(2)->all();
322 323 324
        $this->assertEquals(1, count($customers));
        $this->assertEquals('user3', $customers[0]->name);

Qiang Xue committed
325
        $customers = $customerClass::find()->orderBy('id')->limit(2)->offset(1)->all();
326 327 328 329
        $this->assertEquals(2, count($customers));
        $this->assertEquals('user2', $customers[0]->name);
        $this->assertEquals('user3', $customers[1]->name);

Qiang Xue committed
330
        $customers = $customerClass::find()->limit(2)->offset(3)->all();
331 332 333
        $this->assertEquals(0, count($customers));

        // one()
Qiang Xue committed
334
        $customer = $customerClass::find()->orderBy('id')->one();
335 336
        $this->assertEquals('user1', $customer->name);

Qiang Xue committed
337
        $customer = $customerClass::find()->orderBy('id')->offset(0)->one();
338 339
        $this->assertEquals('user1', $customer->name);

Qiang Xue committed
340
        $customer = $customerClass::find()->orderBy('id')->offset(1)->one();
341 342
        $this->assertEquals('user2', $customer->name);

Qiang Xue committed
343
        $customer = $customerClass::find()->orderBy('id')->offset(2)->one();
344 345
        $this->assertEquals('user3', $customer->name);

Qiang Xue committed
346
        $customer = $customerClass::find()->offset(3)->one();
347 348 349 350 351 352
        $this->assertNull($customer);

    }

    public function testFindComplexCondition()
    {
Qiang Xue committed
353 354 355
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

356
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
357 358
        $this->assertEquals(2, $customerClass::find()->where(['OR', ['name' => 'user1'], ['name' => 'user2']])->count());
        $this->assertEquals(2, count($customerClass::find()->where(['OR', ['name' => 'user1'], ['name' => 'user2']])->all()));
359

Qiang Xue committed
360 361
        $this->assertEquals(2, $customerClass::find()->where(['name' => ['user1', 'user2']])->count());
        $this->assertEquals(2, count($customerClass::find()->where(['name' => ['user1', 'user2']])->all()));
362

Qiang Xue committed
363 364
        $this->assertEquals(1, $customerClass::find()->where(['AND', ['name' => ['user2', 'user3']], ['BETWEEN', 'status', 2, 4]])->count());
        $this->assertEquals(1, count($customerClass::find()->where(['AND', ['name' => ['user2', 'user3']], ['BETWEEN', 'status', 2, 4]])->all()));
365 366 367 368
    }

    public function testFindNullValues()
    {
Qiang Xue committed
369 370 371
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

372
        /** @var TestCase|ActiveRecordTestTrait $this */
Alexander Makarov committed
373
        $customer = $customerClass::findOne(2);
374 375 376 377
        $customer->name = null;
        $customer->save(false);
        $this->afterSave();

Qiang Xue committed
378
        $result = $customerClass::find()->where(['name' => null])->all();
379 380 381 382 383 384
        $this->assertEquals(1, count($result));
        $this->assertEquals(2, reset($result)->primaryKey);
    }

    public function testExists()
    {
Qiang Xue committed
385 386 387
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

388
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
389 390 391 392 393 394 395 396
        $this->assertTrue($customerClass::find()->where(['id' => 2])->exists());
        $this->assertFalse($customerClass::find()->where(['id' => 5])->exists());
        $this->assertTrue($customerClass::find()->where(['name' => 'user1'])->exists());
        $this->assertFalse($customerClass::find()->where(['name' => 'user5'])->exists());

        $this->assertTrue($customerClass::find()->where(['id' => [2, 3]])->exists());
        $this->assertTrue($customerClass::find()->where(['id' => [2, 3]])->offset(1)->exists());
        $this->assertFalse($customerClass::find()->where(['id' => [2, 3]])->offset(2)->exists());
397 398 399 400
    }

    public function testFindLazy()
    {
Qiang Xue committed
401 402 403
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

404
        /** @var TestCase|ActiveRecordTestTrait $this */
Alexander Makarov committed
405
        $customer = $customerClass::findOne(2);
406 407 408 409 410 411 412 413 414 415 416
        $this->assertFalse($customer->isRelationPopulated('orders'));
        $orders = $customer->orders;
        $this->assertTrue($customer->isRelationPopulated('orders'));
        $this->assertEquals(2, count($orders));
        $this->assertEquals(1, count($customer->relatedRecords));

        // unset
        unset($customer['orders']);
        $this->assertFalse($customer->isRelationPopulated('orders'));

        /** @var Customer $customer */
Alexander Makarov committed
417
        $customer = $customerClass::findOne(2);
418 419 420 421 422 423 424 425 426 427 428
        $this->assertFalse($customer->isRelationPopulated('orders'));
        $orders = $customer->getOrders()->where(['id' => 3])->all();
        $this->assertFalse($customer->isRelationPopulated('orders'));
        $this->assertEquals(0, count($customer->relatedRecords));

        $this->assertEquals(1, count($orders));
        $this->assertEquals(3, $orders[0]->id);
    }

    public function testFindEager()
    {
Qiang Xue committed
429 430 431 432 433
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

434
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
435
        $customers = $customerClass::find()->with('orders')->indexBy('id')->all();
436 437 438 439 440 441 442 443 444 445 446 447
        ksort($customers);
        $this->assertEquals(3, count($customers));
        $this->assertTrue($customers[1]->isRelationPopulated('orders'));
        $this->assertTrue($customers[2]->isRelationPopulated('orders'));
        $this->assertTrue($customers[3]->isRelationPopulated('orders'));
        $this->assertEquals(1, count($customers[1]->orders));
        $this->assertEquals(2, count($customers[2]->orders));
        $this->assertEquals(0, count($customers[3]->orders));
        // unset
        unset($customers[1]->orders);
        $this->assertFalse($customers[1]->isRelationPopulated('orders'));

Qiang Xue committed
448
        $customer = $customerClass::find()->where(['id' => 1])->with('orders')->one();
449 450 451 452 453
        $this->assertTrue($customer->isRelationPopulated('orders'));
        $this->assertEquals(1, count($customer->orders));
        $this->assertEquals(1, count($customer->relatedRecords));

        // multiple with() calls
Qiang Xue committed
454
        $orders = $orderClass::find()->with('customer', 'items')->all();
455 456 457
        $this->assertEquals(3, count($orders));
        $this->assertTrue($orders[0]->isRelationPopulated('customer'));
        $this->assertTrue($orders[0]->isRelationPopulated('items'));
Qiang Xue committed
458
        $orders = $orderClass::find()->with('customer')->with('items')->all();
459 460 461 462 463 464 465
        $this->assertEquals(3, count($orders));
        $this->assertTrue($orders[0]->isRelationPopulated('customer'));
        $this->assertTrue($orders[0]->isRelationPopulated('items'));
    }

    public function testFindLazyVia()
    {
Qiang Xue committed
466 467 468
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

469 470
        /** @var TestCase|ActiveRecordTestTrait $this */
        /** @var Order $order */
Alexander Makarov committed
471
        $order = $orderClass::findOne(1);
472 473 474 475 476 477 478 479
        $this->assertEquals(1, $order->id);
        $this->assertEquals(2, count($order->items));
        $this->assertEquals(1, $order->items[0]->id);
        $this->assertEquals(2, $order->items[1]->id);
    }

    public function testFindLazyVia2()
    {
Qiang Xue committed
480 481 482
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

483 484
        /** @var TestCase|ActiveRecordTestTrait $this */
        /** @var Order $order */
Alexander Makarov committed
485
        $order = $orderClass::findOne(1);
486 487 488 489 490 491
        $order->id = 100;
        $this->assertEquals([], $order->items);
    }

    public function testFindEagerViaRelation()
    {
Qiang Xue committed
492 493 494
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

495
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
496
        $orders = $orderClass::find()->with('items')->orderBy('id')->all();
497 498 499 500 501 502 503 504 505 506 507
        $this->assertEquals(3, count($orders));
        $order = $orders[0];
        $this->assertEquals(1, $order->id);
        $this->assertTrue($order->isRelationPopulated('items'));
        $this->assertEquals(2, count($order->items));
        $this->assertEquals(1, $order->items[0]->id);
        $this->assertEquals(2, $order->items[1]->id);
    }

    public function testFindNestedRelation()
    {
Qiang Xue committed
508 509 510
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();

511
        /** @var TestCase|ActiveRecordTestTrait $this */
Qiang Xue committed
512
        $customers = $customerClass::find()->with('orders', 'orders.items')->indexBy('id')->all();
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
        ksort($customers);
        $this->assertEquals(3, count($customers));
        $this->assertTrue($customers[1]->isRelationPopulated('orders'));
        $this->assertTrue($customers[2]->isRelationPopulated('orders'));
        $this->assertTrue($customers[3]->isRelationPopulated('orders'));
        $this->assertEquals(1, count($customers[1]->orders));
        $this->assertEquals(2, count($customers[2]->orders));
        $this->assertEquals(0, count($customers[3]->orders));
        $this->assertTrue($customers[1]->orders[0]->isRelationPopulated('items'));
        $this->assertTrue($customers[2]->orders[0]->isRelationPopulated('items'));
        $this->assertTrue($customers[2]->orders[1]->isRelationPopulated('items'));
        $this->assertEquals(2, count($customers[1]->orders[0]->items));
        $this->assertEquals(3, count($customers[2]->orders[0]->items));
        $this->assertEquals(1, count($customers[2]->orders[1]->items));
    }

    /**
     * Ensure ActiveRelationTrait does preserve order of items on find via()
     * https://github.com/yiisoft/yii2/issues/1310
     */
    public function testFindEagerViaRelationPreserveOrder()
    {
Qiang Xue committed
535 536 537
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
        /** @var TestCase|ActiveRecordTestTrait $this */

        /*
        Item (name, category_id)
        Order (customer_id, created_at, total)
        OrderItem (order_id, item_id, quantity, subtotal)

        Result should be the following:

        Order 1: 1, 1325282384, 110.0
        - orderItems:
            OrderItem: 1, 1, 1, 30.0
            OrderItem: 1, 2, 2, 40.0
        - itemsInOrder:
            Item 1: 'Agile Web Application Development with Yii1.1 and PHP5', 1
            Item 2: 'Yii 1.1 Application Development Cookbook', 1

        Order 2: 2, 1325334482, 33.0
        - orderItems:
            OrderItem: 2, 3, 1, 8.0
            OrderItem: 2, 4, 1, 10.0
            OrderItem: 2, 5, 1, 15.0
        - itemsInOrder:
            Item 5: 'Cars', 2
            Item 3: 'Ice Age', 2
            Item 4: 'Toy Story', 2
        Order 3: 2, 1325502201, 40.0
        - orderItems:
            OrderItem: 3, 2, 1, 40.0
        - itemsInOrder:
            Item 3: 'Ice Age', 2
         */
Qiang Xue committed
570
        $orders = $orderClass::find()->with('itemsInOrder1')->orderBy('created_at')->all();
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
        $this->assertEquals(3, count($orders));

        $order = $orders[0];
        $this->assertEquals(1, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder1'));
        $this->assertEquals(2, count($order->itemsInOrder1));
        $this->assertEquals(1, $order->itemsInOrder1[0]->id);
        $this->assertEquals(2, $order->itemsInOrder1[1]->id);

        $order = $orders[1];
        $this->assertEquals(2, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder1'));
        $this->assertEquals(3, count($order->itemsInOrder1));
        $this->assertEquals(5, $order->itemsInOrder1[0]->id);
        $this->assertEquals(3, $order->itemsInOrder1[1]->id);
        $this->assertEquals(4, $order->itemsInOrder1[2]->id);

        $order = $orders[2];
        $this->assertEquals(3, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder1'));
        $this->assertEquals(1, count($order->itemsInOrder1));
        $this->assertEquals(2, $order->itemsInOrder1[0]->id);
    }

    // different order in via table
    public function testFindEagerViaRelationPreserveOrderB()
    {
Qiang Xue committed
598 599 600 601
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();

        $orders = $orderClass::find()->with('itemsInOrder2')->orderBy('created_at')->all();
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
        $this->assertEquals(3, count($orders));

        $order = $orders[0];
        $this->assertEquals(1, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder2'));
        $this->assertEquals(2, count($order->itemsInOrder2));
        $this->assertEquals(1, $order->itemsInOrder2[0]->id);
        $this->assertEquals(2, $order->itemsInOrder2[1]->id);

        $order = $orders[1];
        $this->assertEquals(2, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder2'));
        $this->assertEquals(3, count($order->itemsInOrder2));
        $this->assertEquals(5, $order->itemsInOrder2[0]->id);
        $this->assertEquals(3, $order->itemsInOrder2[1]->id);
        $this->assertEquals(4, $order->itemsInOrder2[2]->id);

        $order = $orders[2];
        $this->assertEquals(3, $order->id);
        $this->assertTrue($order->isRelationPopulated('itemsInOrder2'));
        $this->assertEquals(1, count($order->itemsInOrder2));
        $this->assertEquals(2, $order->itemsInOrder2[0]->id);
    }

    public function testLink()
    {
Qiang Xue committed
628 629 630 631 632
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        /** @var \yii\db\ActiveRecordInterface $itemClass */
        /** @var \yii\db\ActiveRecordInterface $orderItemClass */
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();
633 634
        $orderClass = $this->getOrderClass();
        $orderItemClass = $this->getOrderItemClass();
Qiang Xue committed
635
        $itemClass = $this->getItemClass();
636
        /** @var TestCase|ActiveRecordTestTrait $this */
Alexander Makarov committed
637
        $customer = $customerClass::findOne(2);
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
        $this->assertEquals(2, count($customer->orders));

        // has many
        $order = new $orderClass;
        $order->total = 100;
        $this->assertTrue($order->isNewRecord);
        $customer->link('orders', $order);
        $this->afterSave();
        $this->assertEquals(3, count($customer->orders));
        $this->assertFalse($order->isNewRecord);
        $this->assertEquals(3, count($customer->getOrders()->all()));
        $this->assertEquals(2, $order->customer_id);

        // belongs to
        $order = new $orderClass;
        $order->total = 100;
        $this->assertTrue($order->isNewRecord);
Alexander Makarov committed
655
        $customer = $customerClass::findOne(1);
656 657 658 659 660 661 662
        $this->assertNull($order->customer);
        $order->link('customer', $customer);
        $this->assertFalse($order->isNewRecord);
        $this->assertEquals(1, $order->customer_id);
        $this->assertEquals(1, $order->customer->primaryKey);

        // via model
Alexander Makarov committed
663
        $order = $orderClass::findOne(1);
664 665
        $this->assertEquals(2, count($order->items));
        $this->assertEquals(2, count($order->orderItems));
Alexander Makarov committed
666
        $orderItem = $orderItemClass::findOne(['order_id' => 1, 'item_id' => 3]);
667
        $this->assertNull($orderItem);
Alexander Makarov committed
668
        $item = $itemClass::findOne(3);
669 670 671 672
        $order->link('items', $item, ['quantity' => 10, 'subtotal' => 100]);
        $this->afterSave();
        $this->assertEquals(3, count($order->items));
        $this->assertEquals(3, count($order->orderItems));
Alexander Makarov committed
673
        $orderItem = $orderItemClass::findOne(['order_id' => 1, 'item_id' => 3]);
674 675 676 677 678 679 680
        $this->assertTrue($orderItem instanceof $orderItemClass);
        $this->assertEquals(10, $orderItem->quantity);
        $this->assertEquals(100, $orderItem->subtotal);
    }

    public function testUnlink()
    {
Qiang Xue committed
681 682 683 684
        /** @var \yii\db\ActiveRecordInterface $customerClass */
        $customerClass = $this->getCustomerClass();
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();
685 686 687
        /** @var \yii\db\ActiveRecordInterface $orderWithNullFKClass */
        $orderWithNullFKClass = $this->getOrderWithNullFKClass();
        /** @var \yii\db\ActiveRecordInterface $orderItemsWithNullFKClass */
688
        $orderItemsWithNullFKClass = $this->getOrderItemWithNullFKmClass();
689 690


Qiang Xue committed
691

692
        /** @var TestCase|ActiveRecordTestTrait $this */
693 694 695 696 697 698 699 700 701 702 703 704
        // has many without delete
        $customer = $customerClass::findOne(2);
        $this->assertEquals(2, count($customer->ordersWithNullFK));
        $customer->unlink('ordersWithNullFK', $customer->ordersWithNullFK[1], false);

        $this->assertEquals(1, count($customer->ordersWithNullFK));
        $orderWithNullFK = $orderWithNullFKClass::findOne(3);

        $this->assertEquals(3,$orderWithNullFK->id);
        $this->assertNull($orderWithNullFK->customer_id);

        // has many with delete
Alexander Makarov committed
705
        $customer = $customerClass::findOne(2);
706 707
        $this->assertEquals(2, count($customer->orders));
        $customer->unlink('orders', $customer->orders[1], true);
708
        $this->afterSave();
709

710
        $this->assertEquals(1, count($customer->orders));
Alexander Makarov committed
711
        $this->assertNull($orderClass::findOne(3));
712

713
        // via model with delete
Alexander Makarov committed
714
        $order = $orderClass::findOne(2);
715 716 717
        $this->assertEquals(3, count($order->items));
        $this->assertEquals(3, count($order->orderItems));
        $order->unlink('items', $order->items[2], true);
718
        $this->afterSave();
719

720 721
        $this->assertEquals(2, count($order->items));
        $this->assertEquals(2, count($order->orderItems));
722 723 724 725

        // via model without delete
        $this->assertEquals(3, count($order->itemsWithNullFK));
        $order->unlink('itemsWithNullFK', $order->itemsWithNullFK[2], false);
726
        $this->afterSave();
727 728 729 730 731 732 733

        $this->assertEquals(2, count($order->itemsWithNullFK));
        $this->assertEquals(2, count($order->orderItems));
    }

    public function testUnlinkAll()
    {
Alexander Makarov committed
734
        /** @var \yii\db\ActiveRecordInterface $customerClass */
735 736 737
        $customerClass = $this->getCustomerClass();
        /** @var \yii\db\ActiveRecordInterface $orderClass */
        $orderClass = $this->getOrderClass();
738 739 740 741 742
        /** @var \yii\db\ActiveRecordInterface $orderItemClass */
        $orderItemClass = $this->getOrderItemClass();
        /** @var \yii\db\ActiveRecordInterface $itemClass */
        $itemClass = $this->getItemClass();
        /** @var \yii\db\ActiveRecordInterface $orderWithNullFKClass */
743 744
        $orderWithNullFKClass = $this->getOrderWithNullFKClass();
        /** @var \yii\db\ActiveRecordInterface $orderItemsWithNullFKClass */
745
        $orderItemsWithNullFKClass = $this->getOrderItemWithNullFKmClass();
746 747 748 749 750

        /** @var TestCase|ActiveRecordTestTrait $this */
        // has many with delete
        $customer = $customerClass::findOne(2);
        $this->assertEquals(2, count($customer->orders));
751
        $this->assertEquals(3, $orderClass::find()->count());
752
        $customer->unlinkAll('orders', true);
753 754
        $this->afterSave();
        $this->assertEquals(1, $orderClass::find()->count());
755 756 757 758 759 760 761 762 763
        $this->assertEquals(0, count($customer->orders));

        $this->assertNull($orderClass::findOne(2));
        $this->assertNull($orderClass::findOne(3));


        // has many without delete
        $customer = $customerClass::findOne(2);
        $this->assertEquals(2, count($customer->ordersWithNullFK));
764
        $this->assertEquals(3, $orderWithNullFKClass::find()->count());
765
        $customer->unlinkAll('ordersWithNullFK', false);
766
        $this->afterSave();
767
        $this->assertEquals(0, count($customer->ordersWithNullFK));
768 769
        $this->assertEquals(3, $orderWithNullFKClass::find()->count());
        $this->assertEquals(2, $orderWithNullFKClass::find()->where(['AND', ['id' => [2, 3]], ['customer_id' => null]])->count());
770 771 772 773 774 775


        // via model with delete
        /** @var Order $order */
        $order = $orderClass::findOne(1);
        $this->assertEquals(2, count($order->books));
Carsten Brandt committed
776
        $orderItemCount = $orderItemClass::find()->count();
777
        $this->assertEquals(5, $itemClass::find()->count());
778
        $order->unlinkAll('books', true);
779 780
        $this->afterSave();
        $this->assertEquals(5, $itemClass::find()->count());
Carsten Brandt committed
781
        $this->assertEquals($orderItemCount - 2, $orderItemClass::find()->count());
782 783 784
        $this->assertEquals(0, count($order->books));

        // via model without delete
785
        $this->assertEquals(2, count($order->booksWithNullFK));
Carsten Brandt committed
786
        $orderItemCount = $orderItemsWithNullFKClass::find()->count();
787
        $this->assertEquals(5, $itemClass::find()->count());
788
        $order->unlinkAll('booksWithNullFK',false);
789 790
        $this->afterSave();
        $this->assertEquals(0, count($order->booksWithNullFK));
Carsten Brandt committed
791 792
        $this->assertEquals(2, $orderItemsWithNullFKClass::find()->where(['AND', ['item_id' => [1, 2]], ['order_id' => null]])->count());
        $this->assertEquals($orderItemCount, $orderItemsWithNullFKClass::find()->count());
793 794 795
        $this->assertEquals(5, $itemClass::find()->count());

        // via table is covered in \yiiunit\framework\db\ActiveRecordTest::testUnlinkAllViaTable()
796 797 798 799 800 801 802
    }

    public static $afterSaveNewRecord;
    public static $afterSaveInsert;

    public function testInsert()
    {
Qiang Xue committed
803
        /** @var \yii\db\ActiveRecordInterface $customerClass */
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        $customer = new $customerClass;
        $customer->email = 'user4@example.com';
        $customer->name = 'user4';
        $customer->address = 'address4';

        $this->assertNull($customer->id);
        $this->assertTrue($customer->isNewRecord);
        static::$afterSaveNewRecord = null;
        static::$afterSaveInsert = null;

        $customer->save();
        $this->afterSave();

        $this->assertNotNull($customer->id);
820
        $this->assertTrue(static::$afterSaveNewRecord);
821 822 823 824 825 826
        $this->assertTrue(static::$afterSaveInsert);
        $this->assertFalse($customer->isNewRecord);
    }

    public function testUpdate()
    {
Qiang Xue committed
827
        /** @var \yii\db\ActiveRecordInterface $customerClass */
828 829 830
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // save
Alexander Makarov committed
831
        $customer = $customerClass::findOne(2);
832 833 834 835 836 837 838 839 840 841 842 843 844
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals('user2', $customer->name);
        $this->assertFalse($customer->isNewRecord);
        static::$afterSaveNewRecord = null;
        static::$afterSaveInsert = null;

        $customer->name = 'user2x';
        $customer->save();
        $this->afterSave();
        $this->assertEquals('user2x', $customer->name);
        $this->assertFalse($customer->isNewRecord);
        $this->assertFalse(static::$afterSaveNewRecord);
        $this->assertFalse(static::$afterSaveInsert);
Alexander Makarov committed
845
        $customer2 = $customerClass::findOne(2);
846 847 848
        $this->assertEquals('user2x', $customer2->name);

        // updateAll
Alexander Makarov committed
849
        $customer = $customerClass::findOne(3);
850 851 852 853
        $this->assertEquals('user3', $customer->name);
        $ret = $customerClass::updateAll(['name' => 'temp'], ['id' => 3]);
        $this->afterSave();
        $this->assertEquals(1, $ret);
Alexander Makarov committed
854
        $customer = $customerClass::findOne(3);
855 856 857 858 859 860 861 862 863 864 865 866 867
        $this->assertEquals('temp', $customer->name);

        $ret = $customerClass::updateAll(['name' => 'tempX']);
        $this->afterSave();
        $this->assertEquals(3, $ret);

        $ret = $customerClass::updateAll(['name' => 'temp'], ['name' => 'user6']);
        $this->afterSave();
        $this->assertEquals(0, $ret);
    }

    public function testUpdateAttributes()
    {
Qiang Xue committed
868
        /** @var \yii\db\ActiveRecordInterface $customerClass */
869 870 871
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // save
Alexander Makarov committed
872
        $customer = $customerClass::findOne(2);
873 874 875 876 877 878 879 880 881 882 883 884
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals('user2', $customer->name);
        $this->assertFalse($customer->isNewRecord);
        static::$afterSaveNewRecord = null;
        static::$afterSaveInsert = null;

        $customer->updateAttributes(['name' => 'user2x']);
        $this->afterSave();
        $this->assertEquals('user2x', $customer->name);
        $this->assertFalse($customer->isNewRecord);
        $this->assertFalse(static::$afterSaveNewRecord);
        $this->assertFalse(static::$afterSaveInsert);
Alexander Makarov committed
885
        $customer2 = $customerClass::findOne(2);
886 887
        $this->assertEquals('user2x', $customer2->name);

Alexander Makarov committed
888
        $customer = $customerClass::findOne(1);
889 890 891 892 893 894 895
        $this->assertEquals('user1', $customer->name);
        $this->assertEquals(1, $customer->status);
        $customer->name = 'user1x';
        $customer->status = 2;
        $customer->updateAttributes(['name']);
        $this->assertEquals('user1x', $customer->name);
        $this->assertEquals(2, $customer->status);
Alexander Makarov committed
896
        $customer = $customerClass::findOne(1);
897 898 899 900 901 902
        $this->assertEquals('user1x', $customer->name);
        $this->assertEquals(1, $customer->status);
    }

    public function testUpdateCounters()
    {
Qiang Xue committed
903
        /** @var \yii\db\ActiveRecordInterface $orderItemClass */
904 905 906 907
        $orderItemClass = $this->getOrderItemClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // updateCounters
        $pk = ['order_id' => 2, 'item_id' => 4];
Alexander Makarov committed
908
        $orderItem = $orderItemClass::findOne($pk);
909 910 911 912 913
        $this->assertEquals(1, $orderItem->quantity);
        $ret = $orderItem->updateCounters(['quantity' => -1]);
        $this->afterSave();
        $this->assertEquals(1, $ret);
        $this->assertEquals(0, $orderItem->quantity);
Alexander Makarov committed
914
        $orderItem = $orderItemClass::findOne($pk);
915 916 917 918
        $this->assertEquals(0, $orderItem->quantity);

        // updateAllCounters
        $pk = ['order_id' => 1, 'item_id' => 2];
Alexander Makarov committed
919
        $orderItem = $orderItemClass::findOne($pk);
920 921 922 923 924 925 926
        $this->assertEquals(2, $orderItem->quantity);
        $ret = $orderItemClass::updateAllCounters([
            'quantity' => 3,
            'subtotal' => -10,
        ], $pk);
        $this->afterSave();
        $this->assertEquals(1, $ret);
Alexander Makarov committed
927
        $orderItem = $orderItemClass::findOne($pk);
928 929 930 931 932 933
        $this->assertEquals(5, $orderItem->quantity);
        $this->assertEquals(30, $orderItem->subtotal);
    }

    public function testDelete()
    {
Qiang Xue committed
934
        /** @var \yii\db\ActiveRecordInterface $customerClass */
935 936 937
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        // delete
Alexander Makarov committed
938
        $customer = $customerClass::findOne(2);
939 940 941 942
        $this->assertTrue($customer instanceof $customerClass);
        $this->assertEquals('user2', $customer->name);
        $customer->delete();
        $this->afterSave();
Alexander Makarov committed
943
        $customer = $customerClass::findOne(2);
944 945 946
        $this->assertNull($customer);

        // deleteAll
Qiang Xue committed
947
        $customers = $customerClass::find()->all();
948 949 950 951
        $this->assertEquals(2, count($customers));
        $ret = $customerClass::deleteAll();
        $this->afterSave();
        $this->assertEquals(2, $ret);
Qiang Xue committed
952
        $customers = $customerClass::find()->all();
953 954 955 956 957 958 959 960 961 962 963 964 965
        $this->assertEquals(0, count($customers));

        $ret = $customerClass::deleteAll();
        $this->afterSave();
        $this->assertEquals(0, $ret);
    }

    /**
     * Some PDO implementations(e.g. cubrid) do not support boolean values.
     * Make sure this does not affect AR layer.
     */
    public function testBooleanAttribute()
    {
Qiang Xue committed
966
        /** @var \yii\db\ActiveRecordInterface $customerClass */
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
        $customerClass = $this->getCustomerClass();
        /** @var TestCase|ActiveRecordTestTrait $this */
        $customer = new $customerClass();
        $customer->name = 'boolean customer';
        $customer->email = 'mail@example.com';
        $customer->status = true;
        $customer->save(false);

        $customer->refresh();
        $this->assertEquals(1, $customer->status);

        $customer->status = false;
        $customer->save(false);

        $customer->refresh();
        $this->assertEquals(0, $customer->status);

Qiang Xue committed
984
        $customers = $customerClass::find()->where(['status' => true])->all();
985 986
        $this->assertEquals(2, count($customers));

Qiang Xue committed
987
        $customers = $customerClass::find()->where(['status' => false])->all();
988 989 990 991 992
        $this->assertEquals(1, count($customers));
    }

    public function testAfterFind()
    {
Qiang Xue committed
993
        /** @var \yii\db\ActiveRecordInterface $customerClass */
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
        $customerClass = $this->getCustomerClass();
        /** @var BaseActiveRecord $orderClass */
        $orderClass = $this->getOrderClass();
        /** @var TestCase|ActiveRecordTestTrait $this */

        $afterFindCalls = [];
        Event::on(BaseActiveRecord::className(), BaseActiveRecord::EVENT_AFTER_FIND, function ($event) use (&$afterFindCalls) {
            /** @var BaseActiveRecord $ar */
            $ar = $event->sender;
            $afterFindCalls[] = [get_class($ar), $ar->getIsNewRecord(), $ar->getPrimaryKey(), $ar->isRelationPopulated('orders')];
        });

Alexander Makarov committed
1006
        $customer = $customerClass::findOne(1);
1007 1008 1009 1010
        $this->assertNotNull($customer);
        $this->assertEquals([[$customerClass, false, 1, false]], $afterFindCalls);
        $afterFindCalls = [];

Qiang Xue committed
1011
        $customer = $customerClass::find()->where(['id' => 1])->one();
1012 1013 1014 1015
        $this->assertNotNull($customer);
        $this->assertEquals([[$customerClass, false, 1, false]], $afterFindCalls);
        $afterFindCalls = [];

Qiang Xue committed
1016
        $customer = $customerClass::find()->where(['id' => 1])->all();
1017 1018 1019 1020
        $this->assertNotNull($customer);
        $this->assertEquals([[$customerClass, false, 1, false]], $afterFindCalls);
        $afterFindCalls = [];

Qiang Xue committed
1021
        $customer = $customerClass::find()->where(['id' => 1])->with('orders')->all();
1022 1023 1024 1025 1026 1027 1028 1029
        $this->assertNotNull($customer);
        $this->assertEquals([
            [$this->getOrderClass(), false, 1, false],
            [$customerClass, false, 1, true],
        ], $afterFindCalls);
        $afterFindCalls = [];

        if ($this instanceof \yiiunit\extensions\redis\ActiveRecordTest) { // TODO redis does not support orderBy() yet
Qiang Xue committed
1030
            $customer = $customerClass::find()->where(['id' => [1, 2]])->with('orders')->all();
1031 1032
        } else {
            // orderBy is needed to avoid random test failure
Qiang Xue committed
1033
            $customer = $customerClass::find()->where(['id' => [1, 2]])->with('orders')->orderBy('name')->all();
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
        }
        $this->assertNotNull($customer);
        $this->assertEquals([
            [$orderClass, false, 1, false],
            [$orderClass, false, 2, false],
            [$orderClass, false, 3, false],
            [$customerClass, false, 1, true],
            [$customerClass, false, 2, true],
        ], $afterFindCalls);
        $afterFindCalls = [];

        Event::off(BaseActiveRecord::className(), BaseActiveRecord::EVENT_AFTER_FIND);
    }
1047

1048
}