eZ\Publish\SPI\FieldType\Generic\Tests\GenericTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	163
Duplicated Lines	15.95 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	7	1
A	testValidateValid()	0	9	1
A	testValidateInvalid()	0	13	1
A	provideFieldTypeIdentifier()	0	4	1
A	createFieldTypeUnderTest()	0	4	1
A	getValidatorConfigurationSchemaExpectation()	0	4	1
A	getSettingsSchemaExpectation()	0	4	1
A	getEmptyValueExpectation()	0	4	1
A	provideInvalidInputForAcceptValue()	0	9	1
A	provideValidInputForAcceptValue()	0	17	1
A	provideInputForToHash()	13	13	1
A	provideInputForFromHash()	13	13	1
A	provideDataForGetName()	0	6	1
A	createSerializerMock()	0	28	1

<?php

/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
declare(strict_types=1);

namespace eZ\Publish\SPI\FieldType\Generic\Tests;

use eZ\Publish\SPI\FieldType\Tests\FieldTypeTest;
use eZ\Publish\SPI\FieldType\ValueSerializerInterface;
use eZ\Publish\SPI\FieldType\Generic\Tests\Stubs\Type as GenericFieldTypeStub;
use eZ\Publish\SPI\FieldType\Generic\Tests\Stubs\Value as GenericFieldValueStub;
use eZ\Publish\SPI\FieldType\ValidationError;
use eZ\Publish\SPI\Exception\InvalidArgumentException;
use Symfony\Component\Validator\ConstraintViolation;
use Symfony\Component\Validator\ConstraintViolationList;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class GenericTest extends FieldTypeTest
{
    /** @var \eZ\Publish\SPI\FieldType\ValueSerializerInterface|\PHPUnit\Framework\MockObject\MockObject */
    private $serializer;

    /** @var \Symfony\Component\Validator\Validator\ValidatorInterface|\PHPUnit\Framework\MockObject\MockObject */
    private $validator;

    protected function setUp(): void
    {
        parent::setUp();

        $this->serializer = $this->createSerializerMock();
        $this->validator = $this->createMock(ValidatorInterface::class);
    }

    /**
     * @dataProvider provideValidDataForValidate
     */
    public function testValidateValid($fieldDefinitionData, $value): void
    {
        $this->validator
            ->method('validate')
            ->with($value, null)
            ->willReturn($this->createMock(ConstraintViolationListInterface::class));

        parent::testValidateValid($fieldDefinitionData, $value);
    }

    /**
     * @dataProvider provideInvalidDataForValidate
     */
    public function testValidateInvalid($fieldDefinitionData, $value, $errors): void
    {
        $constraintViolationList = new ConstraintViolationList(array_map(function (ValidationError $error) {
            return new ConstraintViolation((string) $error->getTranslatableMessage());

The call to ConstraintViolation::__construct() misses some required arguments starting with $messageTemplate.

        }, $errors));

        $this->validator
            ->method('validate')
            ->with($value, null)
            ->willReturn($constraintViolationList);

        parent::testValidateInvalid($fieldDefinitionData, $value, $errors);
    }

    protected function provideFieldTypeIdentifier(): string
    {
        return 'generic';
    }

    protected function createFieldTypeUnderTest()
    {
        return new GenericFieldTypeStub($this->serializer, $this->validator);

It seems like $this->serializer can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, eZ\Publish\SPI\FieldType\Generic\Type::__construct() does only seem to accept object<eZ\Publish\SPI\FieldType\ValueSerializerInterface>, maybe add an additional type check?

It seems like $this->validator can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, eZ\Publish\SPI\FieldType\Generic\Type::__construct() does only seem to accept object<Symfony\Component\Validator\Validator\ValidatorInterface>, maybe add an additional type check?

    }

    protected function getValidatorConfigurationSchemaExpectation(): array
    {
        return [];
    }

    protected function getSettingsSchemaExpectation(): array
    {
        return [];
    }

    protected function getEmptyValueExpectation()
    {
        return new GenericFieldValueStub();
    }

    public function provideInvalidInputForAcceptValue(): array
    {
        return [
            [
                23,
                InvalidArgumentException::class,
            ],
        ];
    }

    public function provideValidInputForAcceptValue(): array
    {
        return [
            [
                null,
                new GenericFieldValueStub(),
            ],
            [
                '{"value": "foo"}',
                new GenericFieldValueStub('foo'),
            ],
            [
                new GenericFieldValueStub('foo'),
                new GenericFieldValueStub('foo'),
            ],
        ];
    }

    public function provideInputForToHash(): array
    {
        return [
            [
                new GenericFieldValueStub(),
                null,
            ],
            [
                new GenericFieldValueStub('foo'),
                ['value' => 'foo'],
            ],
        ];
    }

    public function provideInputForFromHash(): array
    {
        return [
            [
                null,
                new GenericFieldValueStub(),
            ],
            [
                ['value' => 'foo'],
                new GenericFieldValueStub('foo'),
            ],
        ];
    }

    public function provideDataForGetName(): array
    {
        return [
            [new GenericFieldValueStub('This is a generic value.'), [], 'en_GB', 'This is a generic value.'],
        ];
    }

    private function createSerializerMock(): ValueSerializerInterface
    {
        $serializer = $this->createMock(ValueSerializerInterface::class);

        $serializer

The method method() does not seem to exist on object<PHPUnit\Framework\MockObject\MockObject>.

            ->method('decode')
            ->willReturnCallback(function (string $json) {
                return json_decode($json, true);
            });

        $serializer

The method method() does not seem to exist on object<PHPUnit\Framework\MockObject\MockObject>.

            ->method('normalize')
            ->willReturnCallback(function (GenericFieldValueStub $value) {
                return [
                    'value' => $value->getValue(),
                ];
            });

        $serializer

The method method() does not seem to exist on object<PHPUnit\Framework\MockObject\MockObject>.

            ->method('denormalize')
            ->willReturnCallback(function (array $data, string $valueClass) {
                $this->assertEquals($valueClass, GenericFieldValueStub::class);

                return new GenericFieldValueStub($data['value']);
            });

        return $serializer;
    }
}