ObjectDataSetTest - Code Metrics - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

ObjectDataSetTest A
last analyzed 2024-01-12 07:44 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	109
c	0
b	0
f	0
dl	0
loc	213
rs	10
wmc	6

9 Methods

Rating	Name	Size	Complexity
	dataProvider()	147	?
B	hp$9 ➔ dataProvider()	147	1
A	testCollectRules()	7	1
A	hp$9 ➔ toArray()	3	2
	toArray()	3	?
A	hp$9 ➔ testMoreComplexEmbeddedRule()	29	1
A	hp$9 ➔ toNestedArray()	8	2
	toNestedArray()	8	?
	testMoreComplexEmbeddedRule()	29	?

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Tests\TestEnvironments\Php81\DataSet;

use PHPUnit\Framework\TestCase;
use Traversable;
use Yiisoft\Validator\DataSet\ObjectDataSet;
use Yiisoft\Validator\Rule\Count;
use Yiisoft\Validator\Rule\Each;
use Yiisoft\Validator\Rule\Length;
use Yiisoft\Validator\Rule\Nested;
use Yiisoft\Validator\Rule\Number;
use Yiisoft\Validator\Rule\Required;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\Tests\Support\Data\TitleTrait;
use Yiisoft\Validator\Tests\Support\Rule\NotRuleAttribute;
use Yiisoft\Validator\Tests\TestEnvironments\Support\Data\Charts\Chart;

final class ObjectDataSetTest extends TestCase
{
    /**
     * @dataProvider dataProvider
     *
     * @param RuleInterface[]|RuleInterface[][]|RuleInterface[][][] $expectedRules
     */
    public function testCollectRules(object $object, array $expectedRules): void
    {
        $dataSet = new ObjectDataSet($object);

        $rulesArray = $this->toNestedArray($dataSet->getRules());

        $this->assertEquals($expectedRules, $rulesArray);
    }

    public function dataProvider(): array
    {
        return [
            [
                new class () {
                },
                [],
            ],
            [
                new class () {
                    private $property1;

                },
                [],
            ],
            [
                new class () {
                    #[NotRuleAttribute]
                    private $property1;
                },
                [],
            ],
            [
                new class () {
                    #[Required()]
                    private $property1;
                },
                [
                    'property1' => [
                        new Required(),
                    ],
                ],
            ],
            [
                new class () {
                    use TitleTrait;
                },
                [
                    'title' => [
                        new Length(max: 255),
                    ],
                ],
            ],
            [
                new class () {
                    #[Required()]
                    #[Length(max: 255, skipOnEmpty: true)]
                    private $property1;
                    #[Required()]
                    #[Length(max: 255, skipOnEmpty: true)]
                    private $property2;

                },
                [
                    'property1' => [
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ],
                    'property2' => [
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ],
                ],
            ],
            [
                new class () {
                    #[Each([
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ])]
                    #[Length(max: 255, skipOnEmpty: true)]
                    private $property1;
                },
                [
                    'property1' => [
                        new Each([
                            new Required(),
                            new Length(max: 255, skipOnEmpty: true),
                        ]),
                        new Length(max: 255, skipOnEmpty: true),
                    ],
                ],
            ],
            [
                new class () {
                    #[Nested([
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ])]
                    #[Each([
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ])]
                    #[Length(max: 255, skipOnEmpty: true)]
                    private $property1;
                },
                [
                    'property1' => [
                        new Nested([
                            new Required(),
                            new Length(max: 255, skipOnEmpty: true),
                        ]),
                        new Each([
                            new Required(),
                            new Length(max: 255, skipOnEmpty: true),
                        ]),
                        new Length(max: 255, skipOnEmpty: true),
                    ],
                ],
            ],
            [
                new class () {
                    #[Length(max: 255, skipOnEmpty: true)]
                    #[Length(max: 255, skipOnEmpty: false)]
                    private $property1;
                },
                [
                    'property1' => [
                        new Length(max: 255, skipOnEmpty: true),
                        new Length(max: 255, skipOnEmpty: false),
                    ],
                ],
            ],
            [
                new class () {
                    #[Nested([
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ])]
                    #[Nested([
                        new Required(),
                        new Length(max: 255, skipOnEmpty: true),
                    ])]
                    #[Length(max: 255, skipOnEmpty: true)]
                    #[Length(max: 255, skipOnEmpty: false)]
                    private $property1;
                },
                [
                    'property1' => [
                        new Nested([
                            new Required(),
                            new Length(max: 255, skipOnEmpty: true),
                        ]),
                        new Nested([
                            new Required(),
                            new Length(max: 255, skipOnEmpty: true),
                        ]),
                        new Length(max: 255, skipOnEmpty: true),
                        new Length(max: 255, skipOnEmpty: false),
                    ],
                ],
            ],
        ];
    }

    public function testMoreComplexEmbeddedRule(): void
    {
        $dataSet = new ObjectDataSet(new Chart());
        $expectedRules = [
            'points' => [
                new Each([
                    new Nested([
                        'coordinates' => new Each([
                            new Nested(
                                [
                                    'x' => [new Number(min: -10, max: 10)],
                                    'y' => [new Number(min: -10, max: 10)],
                                ],
                                requirePropertyPath: true,
                                noPropertyPathMessage: 'Custom message 4.',
                            ),
                        ]),
                        'rgb' => [
                            new Count(3),
                            new Each(
                                [new Number(min: 0, max: 255)],
                                incorrectInputMessage: 'Custom message 5.',
                            ),
                        ],
                    ]),
                ]),
            ],
        ];
        $this->assertEquals($expectedRules, $dataSet->getRules());
    }

    private function toArray(iterable $rules): array
    {
        return $rules instanceof Traversable ? iterator_to_array($rules) : (array) $rules;
    }

    private function toNestedArray(iterable $doubleIterable): array
    {
        $actualRules = [];
        foreach ($doubleIterable as $key => $iterable) {
            $actualRules[$key] = $this->toArray($iterable);
        }

        return $actualRules;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Validator\Tests\TestEnvironments\Php81\DataSet;
6
7			use PHPUnit\Framework\TestCase;
8			use Traversable;
9			use Yiisoft\Validator\DataSet\ObjectDataSet;
10			use Yiisoft\Validator\Rule\Count;
11			use Yiisoft\Validator\Rule\Each;
12			use Yiisoft\Validator\Rule\Length;
13			use Yiisoft\Validator\Rule\Nested;
14			use Yiisoft\Validator\Rule\Number;
15			use Yiisoft\Validator\Rule\Required;
16			use Yiisoft\Validator\RuleInterface;
17			use Yiisoft\Validator\Tests\Support\Data\TitleTrait;
18			use Yiisoft\Validator\Tests\Support\Rule\NotRuleAttribute;
19			use Yiisoft\Validator\Tests\TestEnvironments\Support\Data\Charts\Chart;
20
21			final class ObjectDataSetTest extends TestCase
22			{
23			/**
24			* @dataProvider dataProvider
25			*
26			* @param RuleInterface[]\|RuleInterface[][]\|RuleInterface[][][] $expectedRules
27			*/
28			public function testCollectRules(object $object, array $expectedRules): void
29			{
30			$dataSet = new ObjectDataSet($object);
31
32			$rulesArray = $this->toNestedArray($dataSet->getRules());
33
34			$this->assertEquals($expectedRules, $rulesArray);
35			}
36
37			public function dataProvider(): array
38			{
39			return [
40			[
41			new class () {
42			},
43			[],
44			],
45			[
46			new class () {
47			private $property1;
			0 ignored issues – show introduced 2022-12-09 10:25 UTC by Report Bug Copy Issue Report The private property `$property1` is not used, and could be removed. Loading history...
48			},
49			[],
50			],
51			[
52			new class () {
53			#[NotRuleAttribute]
54			private $property1;
55			},
56			[],
57			],
58			[
59			new class () {
60			#[Required()]
61			private $property1;
62			},
63			[
64			'property1' => [
65			new Required(),
66			],
67			],
68			],
69			[
70			new class () {
71			use TitleTrait;
72			},
73			[
74			'title' => [
75			new Length(max: 255),
76			],
77			],
78			],
79			[
80			new class () {
81			#[Required()]
82			#[Length(max: 255, skipOnEmpty: true)]
83			private $property1;
84			#[Required()]
85			#[Length(max: 255, skipOnEmpty: true)]
86			private $property2;
			0 ignored issues – show introduced 2022-12-09 10:25 UTC by Report Bug Copy Issue Report The private property `$property2` is not used, and could be removed. Loading history...
87			},
88			[
89			'property1' => [
90			new Required(),
91			new Length(max: 255, skipOnEmpty: true),
92			],
93			'property2' => [
94			new Required(),
95			new Length(max: 255, skipOnEmpty: true),
96			],
97			],
98			],
99			[
100			new class () {
101			#[Each([
102			new Required(),
103			new Length(max: 255, skipOnEmpty: true),
104			])]
105			#[Length(max: 255, skipOnEmpty: true)]
106			private $property1;
107			},
108			[
109			'property1' => [
110			new Each([
111			new Required(),
112			new Length(max: 255, skipOnEmpty: true),
113			]),
114			new Length(max: 255, skipOnEmpty: true),
115			],
116			],
117			],
118			[
119			new class () {
120			#[Nested([
121			new Required(),
122			new Length(max: 255, skipOnEmpty: true),
123			])]
124			#[Each([
125			new Required(),
126			new Length(max: 255, skipOnEmpty: true),
127			])]
128			#[Length(max: 255, skipOnEmpty: true)]
129			private $property1;
130			},
131			[
132			'property1' => [
133			new Nested([
134			new Required(),
135			new Length(max: 255, skipOnEmpty: true),
136			]),
137			new Each([
138			new Required(),
139			new Length(max: 255, skipOnEmpty: true),
140			]),
141			new Length(max: 255, skipOnEmpty: true),
142			],
143			],
144			],
145			[
146			new class () {
147			#[Length(max: 255, skipOnEmpty: true)]
148			#[Length(max: 255, skipOnEmpty: false)]
149			private $property1;
150			},
151			[
152			'property1' => [
153			new Length(max: 255, skipOnEmpty: true),
154			new Length(max: 255, skipOnEmpty: false),
155			],
156			],
157			],
158			[
159			new class () {
160			#[Nested([
161			new Required(),
162			new Length(max: 255, skipOnEmpty: true),
163			])]
164			#[Nested([
165			new Required(),
166			new Length(max: 255, skipOnEmpty: true),
167			])]
168			#[Length(max: 255, skipOnEmpty: true)]
169			#[Length(max: 255, skipOnEmpty: false)]
170			private $property1;
171			},
172			[
173			'property1' => [
174			new Nested([
175			new Required(),
176			new Length(max: 255, skipOnEmpty: true),
177			]),
178			new Nested([
179			new Required(),
180			new Length(max: 255, skipOnEmpty: true),
181			]),
182			new Length(max: 255, skipOnEmpty: true),
183			new Length(max: 255, skipOnEmpty: false),
184			],
185			],
186			],
187			];
188			}
189
190			public function testMoreComplexEmbeddedRule(): void
191			{
192			$dataSet = new ObjectDataSet(new Chart());
193			$expectedRules = [
194			'points' => [
195			new Each([
196			new Nested([
197			'coordinates' => new Each([
198			new Nested(
199			[
200			'x' => [new Number(min: -10, max: 10)],
201			'y' => [new Number(min: -10, max: 10)],
202			],
203			requirePropertyPath: true,
204			noPropertyPathMessage: 'Custom message 4.',
205			),
206			]),
207			'rgb' => [
208			new Count(3),
209			new Each(
210			[new Number(min: 0, max: 255)],
211			incorrectInputMessage: 'Custom message 5.',
212			),
213			],
214			]),
215			]),
216			],
217			];
218			$this->assertEquals($expectedRules, $dataSet->getRules());
219			}
220
221			private function toArray(iterable $rules): array
222			{
223			return $rules instanceof Traversable ? iterator_to_array($rules) : (array) $rules;
224			}
225
226			private function toNestedArray(iterable $doubleIterable): array
227			{
228			$actualRules = [];
229			foreach ($doubleIterable as $key => $iterable) {
230			$actualRules[$key] = $this->toArray($iterable);
231			}
232
233			return $actualRules;
234			}
235			}
236

yiisoft / validator

ObjectDataSetTest A last analyzed 2024-01-12 07:44 UTC

Complexity

Size/Duplication

Importance

9 Methods

Duplication Side-by-Side

Filter issues like

ObjectDataSetTest A
last analyzed 2024-01-12 07:44 UTC