ValidatorResolverTest.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
namespace ‪TYPO3\CMS\Extbase\Tests\Functional\Validation;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Object\ObjectManager;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
use ‪TYPO3\CMS\Extbase\Validation\Exception\NoSuchValidatorException;
use ‪TYPO3\CMS\Extbase\Validation\Validator\CollectionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ConjunctionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\GenericObjectValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\NotEmptyValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\StringLengthValidator;
use ‪TYPO3\CMS\Extbase\Validation\ValidatorResolver;
 
class ‪ValidatorResolverTest extends \TYPO3\TestingFramework\Core\Functional\FunctionalTestCase
{
    private ‪$validatorResolver;
 
    protected function ‪setUp()
    {
        parent::setUp();
 
        $this->validatorResolver = $this->getAccessibleMock(
            ValidatorResolver::class,
            ['dummy']
        );
        $this->validatorResolver->injectObjectManager(GeneralUtility::makeInstance(ObjectManager::class));
        $this->validatorResolver->injectReflectionService(GeneralUtility::makeInstance(ReflectionService::class));
    }
 
    public function ‪namespacedShorthandValidatorNamesDataProvider(): array
    {
        return [
            'TYPO3.CMS.Extbase:NotEmpty' => [
                'TYPO3.CMS.Extbase:NotEmpty',
                NotEmptyValidator::class
            ],
            'TYPO3.CMS.Extbase.Tests.Functional.Validation.Fixture:Custom' => [
                'TYPO3.CMS.Extbase.Tests.Functional.Validation.Fixture:Custom',
                Fixture\Validation\Validator\CustomValidator::class
            ]
        ];
    }
 
    public function ‪resolveValidatorObjectNameWithShortHandNotationReturnsValidatorNameIfClassExists(string $validatorName, string $expectedClassName)
    {
        static::assertEquals(
            $expectedClassName,
            $this->validatorResolver->_call('resolveValidatorObjectName', $validatorName)
        );
    }
 
    public function ‪resolveValidatorObjectNameWithShortHandNotationThrowsExceptionIfClassDoesNotExist()
    {
        $this->expectException(NoSuchValidatorException::class);
        $this->expectExceptionCode(1365799920);
 
        $validatorName = 'TYPO3.CMS.Extbase.Tests.Functional.Validation.Fixture:NonExistentValidator';
        $this->validatorResolver->_call('resolveValidatorObjectName', $validatorName);
    }
 
    public function ‪resolveValidatorObjectNameWithShortHandNotationReturnsValidatorNameIfClassExistsButDoesNotImplementValidatorInterface()
    {
        $this->expectException(NoSuchValidatorException::class);
        $this->expectExceptionCode(1365776838);
 
        $validatorName = 'TYPO3.CMS.Extbase.Tests.Functional.Validation.Fixture:CustomValidatorThatDoesNotImplementValidatorInterface';
        $this->validatorResolver->_call('resolveValidatorObjectName', $validatorName);
    }
 
    public function ‪resolveValidatorObjectNameReturnsValidatorNameForFullQualifiedValidatorName()
    {
        $validatorName = Fixture\Validation\Validator\CustomValidator::class;
        $className = Fixture\Validation\Validator\CustomValidator::class;
 
        static::assertEquals(
            $className,
            $this->validatorResolver->_call('resolveValidatorObjectName', $validatorName)
        );
    }
 
    public function ‪resolveValidatorObjectNameReturnsValidatorNameForFullQualifiedValidatorNameWithLeadingBackslash()
    {
        $validatorName = '\\' . Fixture\Validation\Validator\CustomValidator::class;
        $className = Fixture\Validation\Validator\CustomValidator::class;
 
        static::assertEquals(
            $className,
            $this->validatorResolver->_call('resolveValidatorObjectName', $validatorName)
        );
    }
 
    public function ‪resolveValidatorObjectNameThrowsNoSuchValidatorExceptionIfClassDoesNotExist()
    {
        $className = $this->getUniqueId('Foo\\Bar');
        $this->expectException(NoSuchValidatorException::class);
        $this->expectExceptionCode(1365799920);
        $this->validatorResolver->_call('resolveValidatorObjectName', $className);
    }
 
    public function ‪buildMethodArgumentsValidatorConjunctionsReturnsEmptyArrayIfMethodHasNoArguments()
    {
        $controller = GeneralUtility::makeInstance(ObjectManager::class)->get(Fixture\Controller\TestController::class);
        $result = $this->validatorResolver->buildMethodArgumentsValidatorConjunctions(
            $controller,
            'noParamsAction'
        );
 
        static::assertSame([], $result);
    }
 
    public function ‪buildBaseValidatorConjunctionAddsValidatorsDefinedByAnnotationsInTheClassToTheReturnedConjunction()
    {
        $this->validatorResolver->_call(
            'buildBaseValidatorConjunction',
            \‪TYPO3\CMS\‪Extbase\Tests\Functional\Validation\Fixture\Domain\Model\Model::class,
            \‪TYPO3\CMS\‪Extbase\Tests\Functional\Validation\Fixture\Domain\Model\Model::class
        );
 
        $baseValidatorConjunctions = $this->validatorResolver->_get('baseValidatorConjunctions');
        static::assertTrue(is_array($baseValidatorConjunctions));
        static::assertCount(2, $baseValidatorConjunctions);
        static::assertArrayHasKey(\‪TYPO3\CMS\‪Extbase\Tests\Functional\Validation\Fixture\Domain\Model\Model::class, $baseValidatorConjunctions);
        static::assertArrayHasKey(\‪TYPO3\CMS\‪Extbase\Tests\Functional\Validation\Fixture\Domain\Model\AnotherModel::class, $baseValidatorConjunctions);
 
        $conjunctionValidator = $baseValidatorConjunctions[\TYPO3\CMS\Extbase\Tests\Functional\Validation\Fixture\Domain\Model\Model::class];
        static::assertInstanceOf(ConjunctionValidator::class, $conjunctionValidator);
 
        $baseValidators = $conjunctionValidator->getValidators();
        static::assertInstanceOf(\SplObjectStorage::class, $baseValidators);
        $baseValidators->rewind();
 
        ‪$validator = $baseValidators->current();
        static::assertInstanceOf(GenericObjectValidator::class, ‪$validator);
 
        $propertyValidators = ‪$validator->getPropertyValidators();
        static::assertCount(4, $propertyValidators);
        static::assertArrayHasKey('foo', $propertyValidators);
        static::assertArrayHasKey('bar', $propertyValidators);
        static::assertArrayHasKey('baz', $propertyValidators);
        static::assertArrayHasKey('qux', $propertyValidators);
 
        $fooPropertyValidators = $propertyValidators['foo'];
        static::assertInstanceOf(\SplObjectStorage::class, $fooPropertyValidators);
        static::assertCount(3, $fooPropertyValidators);
 
        $fooPropertyValidators->rewind();
        $propertyValidator = $fooPropertyValidators->current();
        static::assertInstanceOf(StringLengthValidator::class, $propertyValidator);
        static::assertSame(['minimum' => 1, 'maximum' => PHP_INT_MAX], $propertyValidator->getOptions());
 
        $fooPropertyValidators->next();
        $propertyValidator = $fooPropertyValidators->current();
        static::assertInstanceOf(StringLengthValidator::class, $propertyValidator);
        static::assertSame(['minimum' => 0, 'maximum' => 10], $propertyValidator->getOptions());
 
        $fooPropertyValidators->next();
        $propertyValidator = $fooPropertyValidators->current();
        static::assertInstanceOf(NotEmptyValidator::class, $propertyValidator);
 
        $barPropertyValidators = $propertyValidators['bar'];
        static::assertInstanceOf(\SplObjectStorage::class, $barPropertyValidators);
        static::assertCount(1, $barPropertyValidators);
 
        $barPropertyValidators->rewind();
        $propertyValidator = $barPropertyValidators->current();
        static::assertInstanceOf(Fixture\Validation\Validator\CustomValidator::class, $propertyValidator);
 
        $bazPropertyValidators = $propertyValidators['baz'];
        static::assertInstanceOf(\SplObjectStorage::class, $bazPropertyValidators);
        static::assertCount(1, $bazPropertyValidators);
 
        $bazPropertyValidators->rewind();
        $propertyValidator = $bazPropertyValidators->current();
        static::assertInstanceOf(CollectionValidator::class, $propertyValidator);
 
        $quxPropertyValidators = $propertyValidators['qux'];
        static::assertInstanceOf(\SplObjectStorage::class, $quxPropertyValidators);
        static::assertCount(1, $quxPropertyValidators);
 
        $quxPropertyValidators->rewind();
        $propertyValidator = $quxPropertyValidators->current();
        static::assertInstanceOf(ConjunctionValidator::class, $propertyValidator);
        static::assertSame(
            $baseValidatorConjunctions[\‪TYPO3\CMS\‪Extbase\Tests\Functional\Validation\Fixture\Domain\Model\AnotherModel::class],
            $propertyValidator
        );
 
        $baseValidators->next();
        ‪$validator = $baseValidators->current();
        static::assertInstanceOf(Fixture\Domain\Validator\ModelValidator::class, ‪$validator);
    }
}