NumberTest::testWhen() - Code Metrics - Inspection of "Docs, part 2" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#408)

unknown

created 2022-12-01 11:57 UTC

NumberTest::testWhen() A

↳ Parent: NumberTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Tests\Rule;

use stdClass;
use Yiisoft\Validator\Rule\Number;
use Yiisoft\Validator\Rule\NumberHandler;
use Yiisoft\Validator\Tests\Rule\Base\DifferentRuleInHandlerTestTrait;
use Yiisoft\Validator\Tests\Rule\Base\RuleTestCase;
use Yiisoft\Validator\Tests\Rule\Base\RuleWithOptionsTestTrait;
use Yiisoft\Validator\Tests\Rule\Base\SkipOnErrorTestTrait;
use Yiisoft\Validator\Tests\Rule\Base\WhenTestTrait;

final class NumberTest extends RuleTestCase
{
    use DifferentRuleInHandlerTestTrait;
    use RuleWithOptionsTestTrait;
    use SkipOnErrorTestTrait;
    use WhenTestTrait;

    public function testGetName(): void
    {
        $rule = new Number();
        $this->assertSame('number', $rule->getName());
    }

    public function dataOptions(): array
    {
        return [
            [
                new Number(),
                [
                    'asInteger' => false,
                    'min' => null,
                    'max' => null,
                    'incorrectInputMessage' => [
                        'template' => 'The allowed types are integer, float and string.',
                        'parameters' => [],
                    ],
                    'notNumberMessage' => [
                        'template' => 'Value must be a number.',
                        'parameters' => [],
                    ],
                    'tooSmallMessage' => [
                        'template' => 'Value must be no less than {min}.',
                        'parameters' => ['min' => null],
                    ],
                    'tooBigMessage' => [
                        'template' => 'Value must be no greater than {max}.',
                        'parameters' => ['max' => null],
                    ],
                    'skipOnEmpty' => false,
                    'skipOnError' => false,
                    'integerPattern' => '/^\s*[+-]?\d+\s*$/',
                    'numberPattern' => '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
                ],
            ],
            [
                new Number(min: 1),
                [
                    'asInteger' => false,
                    'min' => 1,
                    'max' => null,
                    'incorrectInputMessage' => [
                        'template' => 'The allowed types are integer, float and string.',
                        'parameters' => [],
                    ],
                    'notNumberMessage' => [
                        'template' => 'Value must be a number.',
                        'parameters' => [],
                    ],
                    'tooSmallMessage' => [
                        'template' => 'Value must be no less than {min}.',
                        'parameters' => ['min' => 1],
                    ],
                    'tooBigMessage' => [
                        'template' => 'Value must be no greater than {max}.',
                        'parameters' => ['max' => null],
                    ],
                    'skipOnEmpty' => false,
                    'skipOnError' => false,
                    'integerPattern' => '/^\s*[+-]?\d+\s*$/',
                    'numberPattern' => '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
                ],
            ],
            [
                new Number(max: 1),
                [
                    'asInteger' => false,
                    'min' => null,
                    'max' => 1,
                    'incorrectInputMessage' => [
                        'template' => 'The allowed types are integer, float and string.',
                        'parameters' => [],
                    ],
                    'notNumberMessage' => [
                        'template' => 'Value must be a number.',
                        'parameters' => [],
                    ],
                    'tooSmallMessage' => [
                        'template' => 'Value must be no less than {min}.',
                        'parameters' => ['min' => null],
                    ],
                    'tooBigMessage' => [
                        'template' => 'Value must be no greater than {max}.',
                        'parameters' => ['max' => 1],
                    ],
                    'skipOnEmpty' => false,
                    'skipOnError' => false,
                    'integerPattern' => '/^\s*[+-]?\d+\s*$/',
                    'numberPattern' => '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
                ],
            ],
            [
                new Number(min: 2, max: 10),
                [
                    'asInteger' => false,
                    'min' => 2,
                    'max' => 10,
                    'incorrectInputMessage' => [
                        'template' => 'The allowed types are integer, float and string.',
                        'parameters' => [],
                    ],
                    'notNumberMessage' => [
                        'template' => 'Value must be a number.',
                        'parameters' => [],
                    ],
                    'tooSmallMessage' => [
                        'template' => 'Value must be no less than {min}.',
                        'parameters' => ['min' => 2],
                    ],
                    'tooBigMessage' => [
                        'template' => 'Value must be no greater than {max}.',
                        'parameters' => ['max' => 10],
                    ],
                    'skipOnEmpty' => false,
                    'skipOnError' => false,
                    'integerPattern' => '/^\s*[+-]?\d+\s*$/',
                    'numberPattern' => '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
                ],
            ],
            [
                new Number(asInteger: true),
                [
                    'asInteger' => true,
                    'min' => null,
                    'max' => null,
                    'incorrectInputMessage' => [
                        'template' => 'The allowed types are integer, float and string.',
                        'parameters' => [],
                    ],
                    'notNumberMessage' => [
                        'template' => 'Value must be an integer.',
                        'parameters' => [],
                    ],
                    'tooSmallMessage' => [
                        'template' => 'Value must be no less than {min}.',
                        'parameters' => ['min' => null],
                    ],
                    'tooBigMessage' => [
                        'template' => 'Value must be no greater than {max}.',
                        'parameters' => ['max' => null],
                    ],
                    'skipOnEmpty' => false,
                    'skipOnError' => false,
                    'integerPattern' => '/^\s*[+-]?\d+\s*$/',
                    'numberPattern' => '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
                ],
            ],
        ];
    }

    public function dataValidationPassed(): array
    {
        return [
            [20, [new Number()]],
            [0, [new Number()]],
            [.5, [new Number()]],
            [-20, [new Number()]],
            ['20', [new Number()]],
            [25.45, [new Number()]],
            ['25,45', [new Number()]],
            ['-1.23', [new Number()]],
            ['-4.423e-12', [new Number()]],
            ['12E3', [new Number()]],

            [20, [new Number(asInteger: true)]],
            [0, [new Number(asInteger: true)]],
            ['20', [new Number(asInteger: true)]],
            ['020', [new Number(asInteger: true)]],
            [0x14, [new Number(asInteger: true)]],
            ['5.5e1', [new Number()]],

            [1, [new Number(min: 1)]],
            [PHP_INT_MAX + 1, [new Number(min: 1)]],

            [1, [new Number(asInteger: true, min: 1)]],

            [1, [new Number(max: 1)]],
            [1, [new Number(max: 1.25)]],
            ['22e-12', [new Number(max: 1.25)]],
            ['125e-2', [new Number(max: 1.25)]],
            [1, [new Number(asInteger: true, max: 1.25)]],

            [0, [new Number(min: -10, max: 20)]],
            [-10, [new Number(min: -10, max: 20)]],

            [0, [new Number(asInteger: true, min: -10, max: 20)]],
        ];
    }

    public function dataValidationFailed(): array
    {
        $incorrectInputMessage = 'The allowed types are integer, float and string.';
        $notNumberMessage = 'Value must be a number.';
        $notIntegerMessage = 'Value must be an integer.';

        return [
            [false, [new Number()], ['' => [$incorrectInputMessage]]],
            [true, [new Number()], ['' => [$incorrectInputMessage]]],
            [[1, 2, 3], [new Number()], ['' => [$incorrectInputMessage]]],
            [new stdClass(), [new Number()], ['' => [$incorrectInputMessage]]],
            [fopen('php://stdin', 'rb'), [new Number()], ['' => [$incorrectInputMessage]]],

            ['12:45', [new Number()], ['' => [$notNumberMessage]]],
            ['e12', [new Number()], ['' => [$notNumberMessage]]],
            ['-e3', [new Number()], ['' => [$notNumberMessage]]],
            ['-4.534-e-12', [new Number()], ['' => [$notNumberMessage]]],
            ['12.23^4', [new Number()], ['' => [$notNumberMessage]]],
            ['43^32', [new Number()], ['' => [$notNumberMessage]]],

            [25.45, [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['25,45', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['0x14', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],

            ['-1.23', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['-4.423e-12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['12E3', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['e12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['-e3', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['-4.534-e-12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
            ['12.23^4', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],

            [-1, [new Number(min: 1)], ['' => ['Value must be no less than 1.']]],
            ['22e-12', [new Number(min: 1)], ['' => ['Value must be no less than 1.']]],

            [-1, [new Number(asInteger: true, min: 1)], ['' => ['Value must be no less than 1.']]],
            ['22e-12', [new Number(asInteger: true, min: 1)], ['' => [$notIntegerMessage]]],
            [1.5, [new Number(max: 1.25)], ['' => ['Value must be no greater than 1.25.']]],

            // TODO: fix wrong message
            [1.5, [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],
            ['22e-12', [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],
            ['125e-2', [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],

            [-11, [new Number(min: -10, max: 20)], ['' => ['Value must be no less than -10.']]],
            [21, [new Number(min: -10, max: 20)], ['' => ['Value must be no greater than 20.']]],
            [-11, [new Number(asInteger: true, min: -10, max: 20)], ['' => ['Value must be no less than -10.']]],
            [22, [new Number(asInteger: true, min: -10, max: 20)], ['' => ['Value must be no greater than 20.']]],
            ['20e-1', [new Number(asInteger: true, min: -10, max: 20)], ['' => [$notIntegerMessage]]],
            'custom error' => [
                0,
                [new Number(min: 5, tooSmallMessage: 'Value is too small.')],
                ['' => ['Value is too small.']],
            ],
        ];
    }

    public function testSkipOnError(): void
    {
        $this->testSkipOnErrorInternal(new Number(), new Number(skipOnError: true));
    }

    public function testWhen(): void
    {
        $when = static fn (mixed $value): bool => $value !== null;
        $this->testWhenInternal(new Number(), new Number(when: $when));
    }

    protected function getDifferentRuleInHandlerItems(): array
    {
        return [Number::class, NumberHandler::class];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Validator\Tests\Rule;
6
7			use stdClass;
8			use Yiisoft\Validator\Rule\Number;
9			use Yiisoft\Validator\Rule\NumberHandler;
10			use Yiisoft\Validator\Tests\Rule\Base\DifferentRuleInHandlerTestTrait;
11			use Yiisoft\Validator\Tests\Rule\Base\RuleTestCase;
12			use Yiisoft\Validator\Tests\Rule\Base\RuleWithOptionsTestTrait;
13			use Yiisoft\Validator\Tests\Rule\Base\SkipOnErrorTestTrait;
14			use Yiisoft\Validator\Tests\Rule\Base\WhenTestTrait;
15
16			final class NumberTest extends RuleTestCase
17			{
18			use DifferentRuleInHandlerTestTrait;
19			use RuleWithOptionsTestTrait;
20			use SkipOnErrorTestTrait;
21			use WhenTestTrait;
22
23			public function testGetName(): void
24			{
25			$rule = new Number();
26			$this->assertSame('number', $rule->getName());
27			}
28
29			public function dataOptions(): array
30			{
31			return [
32			[
33			new Number(),
34			[
35			'asInteger' => false,
36			'min' => null,
37			'max' => null,
38			'incorrectInputMessage' => [
39			'template' => 'The allowed types are integer, float and string.',
40			'parameters' => [],
41			],
42			'notNumberMessage' => [
43			'template' => 'Value must be a number.',
44			'parameters' => [],
45			],
46			'tooSmallMessage' => [
47			'template' => 'Value must be no less than {min}.',
48			'parameters' => ['min' => null],
49			],
50			'tooBigMessage' => [
51			'template' => 'Value must be no greater than {max}.',
52			'parameters' => ['max' => null],
53			],
54			'skipOnEmpty' => false,
55			'skipOnError' => false,
56			'integerPattern' => '/^\s[+-]?\d+\s$/',
57			'numberPattern' => '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
58			],
59			],
60			[
61			new Number(min: 1),
62			[
63			'asInteger' => false,
64			'min' => 1,
65			'max' => null,
66			'incorrectInputMessage' => [
67			'template' => 'The allowed types are integer, float and string.',
68			'parameters' => [],
69			],
70			'notNumberMessage' => [
71			'template' => 'Value must be a number.',
72			'parameters' => [],
73			],
74			'tooSmallMessage' => [
75			'template' => 'Value must be no less than {min}.',
76			'parameters' => ['min' => 1],
77			],
78			'tooBigMessage' => [
79			'template' => 'Value must be no greater than {max}.',
80			'parameters' => ['max' => null],
81			],
82			'skipOnEmpty' => false,
83			'skipOnError' => false,
84			'integerPattern' => '/^\s[+-]?\d+\s$/',
85			'numberPattern' => '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
86			],
87			],
88			[
89			new Number(max: 1),
90			[
91			'asInteger' => false,
92			'min' => null,
93			'max' => 1,
94			'incorrectInputMessage' => [
95			'template' => 'The allowed types are integer, float and string.',
96			'parameters' => [],
97			],
98			'notNumberMessage' => [
99			'template' => 'Value must be a number.',
100			'parameters' => [],
101			],
102			'tooSmallMessage' => [
103			'template' => 'Value must be no less than {min}.',
104			'parameters' => ['min' => null],
105			],
106			'tooBigMessage' => [
107			'template' => 'Value must be no greater than {max}.',
108			'parameters' => ['max' => 1],
109			],
110			'skipOnEmpty' => false,
111			'skipOnError' => false,
112			'integerPattern' => '/^\s[+-]?\d+\s$/',
113			'numberPattern' => '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
114			],
115			],
116			[
117			new Number(min: 2, max: 10),
118			[
119			'asInteger' => false,
120			'min' => 2,
121			'max' => 10,
122			'incorrectInputMessage' => [
123			'template' => 'The allowed types are integer, float and string.',
124			'parameters' => [],
125			],
126			'notNumberMessage' => [
127			'template' => 'Value must be a number.',
128			'parameters' => [],
129			],
130			'tooSmallMessage' => [
131			'template' => 'Value must be no less than {min}.',
132			'parameters' => ['min' => 2],
133			],
134			'tooBigMessage' => [
135			'template' => 'Value must be no greater than {max}.',
136			'parameters' => ['max' => 10],
137			],
138			'skipOnEmpty' => false,
139			'skipOnError' => false,
140			'integerPattern' => '/^\s[+-]?\d+\s$/',
141			'numberPattern' => '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
142			],
143			],
144			[
145			new Number(asInteger: true),
146			[
147			'asInteger' => true,
148			'min' => null,
149			'max' => null,
150			'incorrectInputMessage' => [
151			'template' => 'The allowed types are integer, float and string.',
152			'parameters' => [],
153			],
154			'notNumberMessage' => [
155			'template' => 'Value must be an integer.',
156			'parameters' => [],
157			],
158			'tooSmallMessage' => [
159			'template' => 'Value must be no less than {min}.',
160			'parameters' => ['min' => null],
161			],
162			'tooBigMessage' => [
163			'template' => 'Value must be no greater than {max}.',
164			'parameters' => ['max' => null],
165			],
166			'skipOnEmpty' => false,
167			'skipOnError' => false,
168			'integerPattern' => '/^\s[+-]?\d+\s$/',
169			'numberPattern' => '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
170			],
171			],
172			];
173			}
174
175			public function dataValidationPassed(): array
176			{
177			return [
178			[20, [new Number()]],
179			[0, [new Number()]],
180			[.5, [new Number()]],
181			[-20, [new Number()]],
182			['20', [new Number()]],
183			[25.45, [new Number()]],
184			['25,45', [new Number()]],
185			['-1.23', [new Number()]],
186			['-4.423e-12', [new Number()]],
187			['12E3', [new Number()]],
188
189			[20, [new Number(asInteger: true)]],
190			[0, [new Number(asInteger: true)]],
191			['20', [new Number(asInteger: true)]],
192			['020', [new Number(asInteger: true)]],
193			[0x14, [new Number(asInteger: true)]],
194			['5.5e1', [new Number()]],
195
196			[1, [new Number(min: 1)]],
197			[PHP_INT_MAX + 1, [new Number(min: 1)]],
198
199			[1, [new Number(asInteger: true, min: 1)]],
200
201			[1, [new Number(max: 1)]],
202			[1, [new Number(max: 1.25)]],
203			['22e-12', [new Number(max: 1.25)]],
204			['125e-2', [new Number(max: 1.25)]],
205			[1, [new Number(asInteger: true, max: 1.25)]],
206
207			[0, [new Number(min: -10, max: 20)]],
208			[-10, [new Number(min: -10, max: 20)]],
209
210			[0, [new Number(asInteger: true, min: -10, max: 20)]],
211			];
212			}
213
214			public function dataValidationFailed(): array
215			{
216			$incorrectInputMessage = 'The allowed types are integer, float and string.';
217			$notNumberMessage = 'Value must be a number.';
218			$notIntegerMessage = 'Value must be an integer.';
219
220			return [
221			[false, [new Number()], ['' => [$incorrectInputMessage]]],
222			[true, [new Number()], ['' => [$incorrectInputMessage]]],
223			[[1, 2, 3], [new Number()], ['' => [$incorrectInputMessage]]],
224			[new stdClass(), [new Number()], ['' => [$incorrectInputMessage]]],
225			[fopen('php://stdin', 'rb'), [new Number()], ['' => [$incorrectInputMessage]]],
226
227			['12:45', [new Number()], ['' => [$notNumberMessage]]],
228			['e12', [new Number()], ['' => [$notNumberMessage]]],
229			['-e3', [new Number()], ['' => [$notNumberMessage]]],
230			['-4.534-e-12', [new Number()], ['' => [$notNumberMessage]]],
231			['12.23^4', [new Number()], ['' => [$notNumberMessage]]],
232			['43^32', [new Number()], ['' => [$notNumberMessage]]],
233
234			[25.45, [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
235			['25,45', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
236			['0x14', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
237
238			['-1.23', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
239			['-4.423e-12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
240			['12E3', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
241			['e12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
242			['-e3', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
243			['-4.534-e-12', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
244			['12.23^4', [new Number(asInteger: true)], ['' => [$notIntegerMessage]]],
245
246			[-1, [new Number(min: 1)], ['' => ['Value must be no less than 1.']]],
247			['22e-12', [new Number(min: 1)], ['' => ['Value must be no less than 1.']]],
248
249			[-1, [new Number(asInteger: true, min: 1)], ['' => ['Value must be no less than 1.']]],
250			['22e-12', [new Number(asInteger: true, min: 1)], ['' => [$notIntegerMessage]]],
251			[1.5, [new Number(max: 1.25)], ['' => ['Value must be no greater than 1.25.']]],
252
253			// TODO: fix wrong message
254			[1.5, [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],
255			['22e-12', [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],
256			['125e-2', [new Number(asInteger: true, max: 1.25)], ['' => [$notIntegerMessage]]],
257
258			[-11, [new Number(min: -10, max: 20)], ['' => ['Value must be no less than -10.']]],
259			[21, [new Number(min: -10, max: 20)], ['' => ['Value must be no greater than 20.']]],
260			[-11, [new Number(asInteger: true, min: -10, max: 20)], ['' => ['Value must be no less than -10.']]],
261			[22, [new Number(asInteger: true, min: -10, max: 20)], ['' => ['Value must be no greater than 20.']]],
262			['20e-1', [new Number(asInteger: true, min: -10, max: 20)], ['' => [$notIntegerMessage]]],
263			'custom error' => [
264			0,
265			[new Number(min: 5, tooSmallMessage: 'Value is too small.')],
266			['' => ['Value is too small.']],
267			],
268			];
269			}
270
271			public function testSkipOnError(): void
272			{
273			$this->testSkipOnErrorInternal(new Number(), new Number(skipOnError: true));
274			}
275
276			public function testWhen(): void
277			{
278			$when = static fn (mixed $value): bool => $value !== null;
279			$this->testWhenInternal(new Number(), new Number(when: $when));
280			}
281
282			protected function getDifferentRuleInHandlerItems(): array
283			{
284			return [Number::class, NumberHandler::class];
285			}
286			}
287

yiisoft / validator

Pull Request — master (#408)

NumberTest::testWhen() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like