CommonBatchQueryResultTest::getAllRowsFromEach() - Code Metrics - Inspection of "Rework tests #2." - yiisoft/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#380)

by Wilmer

created 2022-11-15 20:40 UTC

CommonBatchQueryResultTest::getAllRowsFromEach() A

↳ Parent: CommonBatchQueryResultTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	1
dl	0
loc	9
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Tests\Common;

use PHPUnit\Framework\TestCase;
use Yiisoft\Db\Query\BatchQueryResultInterface;
use Yiisoft\Db\Tests\Support\TestTrait;

use function array_merge;

/**
 * @group mssql
 * @group mysql
 * @group pgsql
 * @group oracle
 * @group sqlite
 */
abstract class CommonBatchQueryResultTest extends TestCase
{
    use TestTrait;

    public function testBatchQueryResult(): void
    {
        /* initialize property test */
        $db = $this->getConnectionWithData();

        $query = $this->getQuery($db);
        $query->from('customer')->orderBy('id');
        $result = $query->batch(2);

        $this->assertInstanceOf(BatchQueryResultInterface::class, $result);
        $this->assertSame(2, $result->getBatchSize());
        $this->assertSame($result->getQuery(), $query);

        /* normal query */
        $query = $this->getQuery($db);
        $query->from('customer')->orderBy('id');
        $allRows = [];
        $batch = $query->batch(2);
        $step = 0;

        foreach ($batch as $rows) {
            $allRows = array_merge($allRows, $rows);
            $step++;
        }

        $this->assertCount(3, $allRows);
        $this->assertSame(2, $step);
        $this->assertSame('user1', $allRows[0]['name']);
        $this->assertSame('user2', $allRows[1]['name']);
        $this->assertSame('user3', $allRows[2]['name']);

        /* rewind */
        $allRows = [];
        $step = 0;

        foreach ($batch as $rows) {
            $allRows = array_merge($allRows, $rows);
            $step++;
        }

        $this->assertCount(3, $allRows);
        $this->assertSame(2, $step);

        $batch->reset();

        /* empty query */
        $query = $this->getQuery($db);
        $query->from('customer')->where(['id' => 100]);
        $allRows = [];
        $batch = $query->batch(2);

        foreach ($batch as $rows) {
            $allRows = array_merge($allRows, $rows);
        }

        $this->assertCount(0, $allRows);

        /* query with index */
        $query = $this->getQuery($db);
        $query->from('customer')->indexBy('name');
        $allRows = [];

        foreach ($query->batch(2) as $rows) {
            $allRows = array_merge($allRows, $rows);
        }

        $this->assertCount(3, $allRows);
        $this->assertSame('address1', $allRows['user1']['address']);
        $this->assertSame('address2', $allRows['user2']['address']);
        $this->assertSame('address3', $allRows['user3']['address']);

        /* each */
        $query = $this->getQuery($db);
        $query->from('customer')->orderBy('id');
        $allRows = [];

        foreach ($query->each(2) as $index => $row) {
            /** @psalm-suppress PossiblyNullArrayOffset */
            $allRows[$index] = $row;
        }

        $this->assertCount(3, $allRows);
        $this->assertSame('user1', $allRows[0]['name']);
        $this->assertSame('user2', $allRows[1]['name']);
        $this->assertSame('user3', $allRows[2]['name']);

        /* each with key */
        $query = $this->getQuery($db);
        $query->from('customer')->orderBy('id')->indexBy('name');
        $allRows = [];

        foreach ($query->each() as $key => $row) {
            $allRows[$key] = $row;
        }

        $this->assertCount(3, $allRows);
        $this->assertSame('address1', $allRows['user1']['address']);
        $this->assertSame('address2', $allRows['user2']['address']);
        $this->assertSame('address3', $allRows['user3']['address']);
    }

    public function testBatchWithoutDbParameter(): void
    {
        $db = $this->getConnectionWithData();

        $query = $this->getQuery($db);
        $query = $query->from('customer')->orderBy('id')->limit(3);
        $customers = $this->getAllRowsFromBatch($query->batch(2));

        $this->assertCount(3, $customers);
        $this->assertEquals('user1', $customers[0]['name']);
        $this->assertEquals('user2', $customers[1]['name']);
        $this->assertEquals('user3', $customers[2]['name']);
    }

    public function testBatchWithIndexBy(): void
    {
        $db = $this->getConnectionWithData();

        $query = $this->getQuery($db);
        $query->from('customer')->orderBy('id')->limit(3)->indexBy('id');
        $customers = $this->getAllRowsFromBatch($query->batch(2));

        $this->assertCount(3, $customers);
        $this->assertEquals('user1', $customers[0]['name']);
        $this->assertEquals('user2', $customers[1]['name']);
        $this->assertEquals('user3', $customers[2]['name']);
    }

    protected function getAllRowsFromBatch(BatchQueryResultInterface $batch): array
    {
        $allRows = [];

        foreach ($batch as $rows) {
            $allRows = array_merge($allRows, $rows);
        }

        return $allRows;
    }

    protected function getAllRowsFromEach(BatchQueryResultInterface $each): array
    {
        $allRows = [];

        foreach ($each as $index => $row) {
            $allRows[$index] = $row;
        }

        return $allRows;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Db\Tests\Common;
6
7			use PHPUnit\Framework\TestCase;
8			use Yiisoft\Db\Query\BatchQueryResultInterface;
9			use Yiisoft\Db\Tests\Support\TestTrait;
10
11			use function array_merge;
12
13			/**
14			* @group mssql
15			* @group mysql
16			* @group pgsql
17			* @group oracle
18			* @group sqlite
19			*/
20			abstract class CommonBatchQueryResultTest extends TestCase
21			{
22			use TestTrait;
23
24			public function testBatchQueryResult(): void
25			{
26			/* initialize property test */
27			$db = $this->getConnectionWithData();
28
29			$query = $this->getQuery($db);
30			$query->from('customer')->orderBy('id');
31			$result = $query->batch(2);
32
33			$this->assertInstanceOf(BatchQueryResultInterface::class, $result);
34			$this->assertSame(2, $result->getBatchSize());
35			$this->assertSame($result->getQuery(), $query);
36
37			/* normal query */
38			$query = $this->getQuery($db);
39			$query->from('customer')->orderBy('id');
40			$allRows = [];
41			$batch = $query->batch(2);
42			$step = 0;
43
44			foreach ($batch as $rows) {
45			$allRows = array_merge($allRows, $rows);
46			$step++;
47			}
48
49			$this->assertCount(3, $allRows);
50			$this->assertSame(2, $step);
51			$this->assertSame('user1', $allRows[0]['name']);
52			$this->assertSame('user2', $allRows[1]['name']);
53			$this->assertSame('user3', $allRows[2]['name']);
54
55			/* rewind */
56			$allRows = [];
57			$step = 0;
58
59			foreach ($batch as $rows) {
60			$allRows = array_merge($allRows, $rows);
61			$step++;
62			}
63
64			$this->assertCount(3, $allRows);
65			$this->assertSame(2, $step);
66
67			$batch->reset();
68
69			/* empty query */
70			$query = $this->getQuery($db);
71			$query->from('customer')->where(['id' => 100]);
72			$allRows = [];
73			$batch = $query->batch(2);
74
75			foreach ($batch as $rows) {
76			$allRows = array_merge($allRows, $rows);
77			}
78
79			$this->assertCount(0, $allRows);
80
81			/* query with index */
82			$query = $this->getQuery($db);
83			$query->from('customer')->indexBy('name');
84			$allRows = [];
85
86			foreach ($query->batch(2) as $rows) {
87			$allRows = array_merge($allRows, $rows);
88			}
89
90			$this->assertCount(3, $allRows);
91			$this->assertSame('address1', $allRows['user1']['address']);
92			$this->assertSame('address2', $allRows['user2']['address']);
93			$this->assertSame('address3', $allRows['user3']['address']);
94
95			/* each */
96			$query = $this->getQuery($db);
97			$query->from('customer')->orderBy('id');
98			$allRows = [];
99
100			foreach ($query->each(2) as $index => $row) {
101			/** @psalm-suppress PossiblyNullArrayOffset */
102			$allRows[$index] = $row;
103			}
104
105			$this->assertCount(3, $allRows);
106			$this->assertSame('user1', $allRows[0]['name']);
107			$this->assertSame('user2', $allRows[1]['name']);
108			$this->assertSame('user3', $allRows[2]['name']);
109
110			/* each with key */
111			$query = $this->getQuery($db);
112			$query->from('customer')->orderBy('id')->indexBy('name');
113			$allRows = [];
114
115			foreach ($query->each() as $key => $row) {
116			$allRows[$key] = $row;
117			}
118
119			$this->assertCount(3, $allRows);
120			$this->assertSame('address1', $allRows['user1']['address']);
121			$this->assertSame('address2', $allRows['user2']['address']);
122			$this->assertSame('address3', $allRows['user3']['address']);
123			}
124
125			public function testBatchWithoutDbParameter(): void
126			{
127			$db = $this->getConnectionWithData();
128
129			$query = $this->getQuery($db);
130			$query = $query->from('customer')->orderBy('id')->limit(3);
131			$customers = $this->getAllRowsFromBatch($query->batch(2));
132
133			$this->assertCount(3, $customers);
134			$this->assertEquals('user1', $customers[0]['name']);
135			$this->assertEquals('user2', $customers[1]['name']);
136			$this->assertEquals('user3', $customers[2]['name']);
137			}
138
139			public function testBatchWithIndexBy(): void
140			{
141			$db = $this->getConnectionWithData();
142
143			$query = $this->getQuery($db);
144			$query->from('customer')->orderBy('id')->limit(3)->indexBy('id');
145			$customers = $this->getAllRowsFromBatch($query->batch(2));
146
147			$this->assertCount(3, $customers);
148			$this->assertEquals('user1', $customers[0]['name']);
149			$this->assertEquals('user2', $customers[1]['name']);
150			$this->assertEquals('user3', $customers[2]['name']);
151			}
152
153			protected function getAllRowsFromBatch(BatchQueryResultInterface $batch): array
154			{
155			$allRows = [];
156
157			foreach ($batch as $rows) {
158			$allRows = array_merge($allRows, $rows);
159			}
160
161			return $allRows;
162			}
163
164			protected function getAllRowsFromEach(BatchQueryResultInterface $each): array
165			{
166			$allRows = [];
167
168			foreach ($each as $index => $row) {
169			$allRows[$index] = $row;
170			}
171
172			return $allRows;
173			}
174			}
175

yiisoft / db

Pull Request — master (#380)

CommonBatchQueryResultTest::getAllRowsFromEach() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like