Yiisoft\Validator\Tests\Rule\CountableLimitHandlerTraitTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ validateLimitsWithWrongRuleData()	0	38	1
	validateLimitsWithWrongRuleData()	0	38	?
	testValidateLimitsWithWrongRule()	0	24	?
A	hp$1 ➔ testValidateLimitsWithWrongRule()	0	24	1
A	hp$0 ➔ getGreaterThanMaxMessage()	0	3	1
A	hp$0 ➔ getLessThanMinMessage()	0	3	1
A	hp$0 ➔ getMax()	0	3	1
A	hp$0 ➔ getMin()	0	3	1
A	hp$1 ➔ validate()	0	3	1
A	hp$0 ➔ getExactly()	0	3	1
A	hp$0 ➔ getNotExactlyMessage()	0	3	1
A	hp$1 ➔ checkValidateLimits()	0	7	1

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Tests\Rule;

use InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use Yiisoft\Validator\CountableLimitInterface;
use Yiisoft\Validator\Result;
use Yiisoft\Validator\Rule\Trait\CountableLimitHandlerTrait;
use Yiisoft\Validator\RuleHandlerInterface;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\Tests\Support\Rule\RuleWithoutOptions;
use Yiisoft\Validator\ValidationContext;

final class CountableLimitHandlerTraitTest extends TestCase
{
    public function validateLimitsWithWrongRuleData(): array
    {
        return [
            [
                new class () implements CountableLimitInterface {
                    public function getMin(): int|null
                    {
                        return null;
                    }

                    public function getMax(): int|null
                    {
                        return null;
                    }

                    public function getExactly(): int|null
                    {
                        return 1;
                    }

                    public function getLessThanMinMessage(): string
                    {
                        return 'less then min message';
                    }

                    public function getGreaterThanMaxMessage(): string
                    {
                        return 'greater then min mesage';
                    }

                    public function getNotExactlyMessage(): string
                    {
                        return 'not exactly message';
                    }
                },
            ],
            [
                new RuleWithoutOptions(),
            ],
        ];
    }

    /**
     * @dataProvider validateLimitsWithWrongRuleData
     */
    public function testValidateLimitsWithWrongRule(CountableLimitInterface|RuleInterface $rule): void
    {
        $handler = new class () implements RuleHandlerInterface {
            use CountableLimitHandlerTrait;

            public function validate(mixed $value, object $rule, ValidationContext $context): Result
            {
                return new Result();
            }

            public function checkValidateLimits(
                CountableLimitInterface|RuleInterface $rule,
                ValidationContext $context,
                int $number,
                Result $result
            ): void {
                $this->validateCountableLimits($rule, $context, $number, $result);
            }
        };
        $context = new ValidationContext();

        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('$rule must implement both LimitInterface and RuleInterface.');
        $handler->checkValidateLimits($rule, $context, 1, new Result());
    }
}