Yiisoft\Validator\Tests\ValidatorFactoryTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ createDataSet()	0	18	1
A	hp$0 ➔ __construct()	0	3	1
A	createTranslatorMock()	0	11	2
A	hp$0 ➔ hasAttribute()	0	3	1
A	testCreateWithInvalidRule()	0	11	1
A	testCreateWithTranslator()	0	21	1
A	hp$0 ➔ getAttributeValue()	0	3	2
	createDataSet()	0	18	?
A	testCreate()	0	22	1

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Tests;

use PHPUnit\Framework\TestCase;
use Yiisoft\I18n\TranslatorInterface;
use Yiisoft\Validator\DataSetInterface;
use Yiisoft\Validator\Result;
use Yiisoft\Validator\ValidatorFactory;

class ValidatorFactoryTest extends TestCase
{
    public function testCreate()
    {
        $validation = new ValidatorFactory();

        $attribute = 'test';
        $errorMessage = 'error message';

        $validator = $validation->create(
            [
                $attribute => [
                    static function () use ($errorMessage) {
                        $result = new Result();
                        $result->addError($errorMessage);
                        return $result;
                    }
                ]
            ]
        );

        $result = $validator->validate($this->createDataSet([$attribute => '']));

        $this->assertSame($errorMessage, $result->getResult($attribute)->getErrors()[0]);
    }

    public function testCreateWithTranslator()
    {
        $translatableMessage = 'test message';
        $validation = new ValidatorFactory($this->createTranslatorMock($translatableMessage));

        $attribute = 'test';
        $validator = $validation->create(
            [
                $attribute => [
                    static function () {
                        $result = new Result();
                        $result->addError('error');
                        return $result;
                    }
                ]
            ]
        );

        $result = $validator->validate($this->createDataSet([$attribute => '']));

        $this->assertSame($translatableMessage, $result->getResult($attribute)->getErrors()[0]);
    }


    public function testCreateWithInvalidRule()
    {
        $validation = new ValidatorFactory();

        $this->expectException(\InvalidArgumentException::class);

        $attribute = 'test';
        $validation->create(
            [
                $attribute => [
                    'invalid rule'
                ]
            ]
        );
    }

    private function createTranslatorMock(string $returnMessage = null): TranslatorInterface
    {
        $translator = $this->createMock(TranslatorInterface::class);

        if ($returnMessage) {
            $translator
                ->method('translate')
                ->willReturn($returnMessage);
        }

        return $translator;

The expression return $translator returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Yiisoft\I18n\TranslatorInterface.

    }

    private function createDataSet(array $attributes): DataSetInterface
    {
        return new class($attributes) implements DataSetInterface {
            private array $attributes;

            public function __construct(array $attributes)
            {
                $this->attributes = $attributes;
            }

            public function getAttributeValue(string $attribute)
            {
                return $this->hasAttribute($attribute) ? $this->attributes[$attribute] : null;
            }

            public function hasAttribute(string $attribute): bool
            {
                return array_key_exists($attribute, $this->attributes);
            }
        };
    }
}