Yokai\EnumBundle\Tests\Validator\Constraints\EnumValidatorTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createValidator()	0	11	1
A	testAcceptOnlyEnum()	0	5	1
A	testEnumIsRequired()	0	5	1
A	testValidEnumIsRequired()	0	5	1
A	testNullIsValid()	0	6	1
A	testValidSingleEnum()	0	6	1
A	testInvalidSingleEnum()	0	12	1
A	testValidMultipleEnum()	0	8	1
A	testInvalidMultipleEnum()	0	13	1

<?php declare(strict_types=1);

namespace Yokai\EnumBundle\Tests\Validator\Constraints;

use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;
use Symfony\Component\Validator\Constraints\Choice;
use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;
use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
use Yokai\EnumBundle\EnumRegistry;
use Yokai\EnumBundle\Tests\Fixtures\GenderEnum;
use Yokai\EnumBundle\Tests\Fixtures\TypeEnum;
use Yokai\EnumBundle\Validator\Constraints\Enum;
use Yokai\EnumBundle\Validator\Constraints\EnumValidator;

/**
 * @author Yann Eugoné <eugone.yann@gmail.com>
 */
class EnumValidatorTest extends ConstraintValidatorTestCase
{
    use ProphecyTrait;

    protected function createValidator(): EnumValidator
    {
        /** @var EnumRegistry|ObjectProphecy $registry */
        $registry = $this->prophesize(EnumRegistry::class);
        $registry->has('state')->willReturn(false);

The method has does only exist in Yokai\EnumBundle\EnumRegistry, but not in Prophecy\Prophecy\ObjectProphecy.

        $registry->has(GenderEnum::class)->willReturn(true);
        $registry->has('type')->willReturn(true);
        $registry->get('type')->willReturn(new TypeEnum);

The method get does only exist in Yokai\EnumBundle\EnumRegistry, but not in Prophecy\Prophecy\ObjectProphecy.

        return new EnumValidator($registry->reveal());

The method reveal does only exist in Prophecy\Prophecy\ObjectProphecy, but not in Yokai\EnumBundle\EnumRegistry.

    }

    public function testAcceptOnlyEnum(): void
    {
        $this->expectException(UnexpectedTypeException::class);
        $this->validator->validate(null, new Choice);
    }

    public function testEnumIsRequired(): void
    {
        $this->expectException(ConstraintDefinitionException::class);
        $this->validator->validate('foo', new Enum);
    }

    public function testValidEnumIsRequired(): void
    {
        $this->expectException(ConstraintDefinitionException::class);
        $this->validator->validate('foo', new Enum('state'));
    }

    public function testNullIsValid(): void
    {
        $this->validator->validate(null, new Enum('type'));

        $this->assertNoViolation();
    }

    public function testValidSingleEnum(): void
    {
        $this->validator->validate('customer', new Enum('type'));

        $this->assertNoViolation();
    }

    public function testInvalidSingleEnum(): void
    {
        $constraint = new Enum(['enum' => 'type', 'message' => 'myMessage']);

        $this->validator->validate('foo', $constraint);

        $this->buildViolation('myMessage')
            ->setParameter('{{ value }}', '"foo"')
            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
            ->setParameter('{{ choices }}', '"customer", "prospect"')
            ->assertRaised();
    }

    public function testValidMultipleEnum(): void
    {
        $constraint = new Enum(['enum' => 'type', 'multiple' => true]);

        $this->validator->validate(['customer', 'prospect'], $constraint);

        $this->assertNoViolation();
    }

    public function testInvalidMultipleEnum(): void
    {
        $constraint = new Enum(['enum' => 'type', 'multiple' => true, 'multipleMessage' => 'myMessage']);

        $this->validator->validate(['customer', 'foo'], $constraint);

        $this->buildViolation('myMessage')
            ->setParameter('{{ value }}', '"foo"')
            ->setInvalidValue('foo')
            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
            ->setParameter('{{ choices }}', '"customer", "prospect"')
            ->assertRaised();
    }
}