AbterPhp\Admin\TestDouble\Validation\StubRulesFactory

Complexity

Total Complexity

4

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	createRulesFactory()	0	16	1
A	createRules()	0	30	2
A	createDefaultRules()	0	4	1

<?php

namespace AbterPhp\Admin\TestDouble\Validation;

use AbterPhp\Framework\Validation\Rules\Uuid;
use Opulence\Validation\Rules\Errors\Compilers\ICompiler;
use Opulence\Validation\Rules\Errors\ErrorTemplateRegistry;
use Opulence\Validation\Rules\Factories\RulesFactory;
use Opulence\Validation\Rules\IRule;
use Opulence\Validation\Rules\RuleExtensionRegistry;
use Opulence\Validation\Rules\Rules;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class StubRulesFactory
{
    /**
     * @return IRule[]
     */
    protected static function createDefaultRules()
    {
        return [
            'uuid' => new Uuid(),
        ];
    }

    /**
     * @param TestCase     $testCase
     * @param IRule[]|null $rules
     *
     * @return RulesFactory|MockObject
     */
    public static function createRulesFactory(TestCase $testCase, array $rules = null): RulesFactory
    {
        $rulesFactoryMock = $testCase->getMockBuilder(RulesFactory::class)
            ->disableOriginalConstructor()
            ->getMock();

        $rulesMock = static::createRules($testCase, $rules);

        $rulesFactoryMock
            ->expects($testCase->any())
            ->method('createRules')
            ->willReturnCallback(function () use ($rulesMock) {
                return clone $rulesMock;
            });

        return $rulesFactoryMock;

The expression return $rulesFactoryMock returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Opulence\Validation\Rules\Factories\RulesFactory.

    }

    /**
     * @param TestCase     $testCase
     * @param IRule[]|null $rules
     *
     * @return Rules
     */
    public static function createRules(TestCase $testCase, ?array $rules = null): Rules
    {
        $rules = $rules ?: static::createDefaultRules();

        /** @var RuleExtensionRegistry|MockObject $ruleExtensionRegistryStub */
        $ruleExtensionRegistryStub = $testCase->getMockBuilder(RuleExtensionRegistry::class)->getMock();

        /** @var ErrorTemplateRegistry|MockObject $errorTemplateRegistryStub */
        $errorTemplateRegistryStub = $testCase->getMockBuilder(ErrorTemplateRegistry::class)->getMock();

        /** @var ICompiler|MockObject $compilerStub */
        $compilerStub = $testCase->getMockBuilder(ICompiler::class)->getMock();

        $rulesStub = new Rules($ruleExtensionRegistryStub, $errorTemplateRegistryStub, $compilerStub);

        $ruleExtensionRegistryStub
            ->expects($testCase->any())
            ->method('hasRule')
            ->willReturnCallback(function (string $methodName) use ($rules): bool {
                return array_key_exists($methodName, $rules);
            });

        $ruleExtensionRegistryStub
            ->expects($testCase->any())
            ->method('getRule')
            ->willReturnCallback(function (string $methodName) use ($rules): IRule {
                return $rules[$methodName];
            });

        return $rulesStub;
    }
}