Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizerTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	134
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	5	5	1
A	testSupportsDenormalization()	6	6	1
A	dataSupportsDenormalization()	22	22	1
A	testDenormalizeWithDenormalizerIsNotSet()	5	5	1
A	testDenormalizeWithWrongData()	7	7	1
A	testDenormalizeWithWrongType()	7	7	1
A	testSetDenormalizerWithNoSerializer()	5	5	1
A	testDenormalize()	47	47	1
A	testHasCacheableSupportsMethod()	7	7	1

<?php

namespace Impl\Serializer\V4;

use Lamoda\IsmpClient\Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizer;
use Lamoda\IsmpClient\Tests\Stub\SerializerDenormalizer;
use Lamoda\IsmpClient\V4\Dto\FacadeDocBodyResponse\Body;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Serializer\Exception\BadMethodCallException;
use Symfony\Component\Serializer\Exception\InvalidArgumentException;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;

final class FacadeDocBodyResponseBodyDenormalizerTest extends TestCase

This class seems to be duplicated in your project.

{
    /**
     * @var FacadeDocBodyResponseBodyDenormalizer
     */
    private $denormalizer;
    /**
     * @var MockObject|DenormalizerInterface
     */
    private $inner;

    protected function setUp(): void
    {
        $this->inner = $this->createMock(SerializerDenormalizer::class);
        $this->denormalizer = new FacadeDocBodyResponseBodyDenormalizer();
    }

    /**
     * @dataProvider dataSupportsDenormalization
     */
    public function testSupportsDenormalization(string $type, array $data, bool $expected): void
    {
        $result = $this->denormalizer->supportsDenormalization($data, $type);

        $this->assertEquals($expected, $result);
    }

    public function dataSupportsDenormalization(): array
    {
        return [
            [
                Body::class,
                [
                    'original_string' => 'foobar',
                ],
                false,
            ],
            [
                Body::class,
                [],
                true,
            ],
            [
                \stdClass::class,
                [],
                false,
            ],
        ];
    }

    public function testDenormalizeWithDenormalizerIsNotSet(): void
    {
        $this->expectException(BadMethodCallException::class);
        $this->denormalizer->denormalize([], Body::class);
    }

    public function testDenormalizeWithWrongData(): void
    {
        $this->denormalizer->setDenormalizer($this->inner);

It seems like $this->inner can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, Lamoda\IsmpClient\Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizer::setDenormalizer() does only seem to accept object<Symfony\Component\Serializer\Normalizer\DenormalizerInterface>, maybe add an additional type check?

        $this->expectException(InvalidArgumentException::class);
        $this->denormalizer->denormalize('wrong', Body::class);
    }

    public function testDenormalizeWithWrongType(): void
    {
        $this->denormalizer->setDenormalizer($this->inner);

It seems like $this->inner can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, Lamoda\IsmpClient\Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizer::setDenormalizer() does only seem to accept object<Symfony\Component\Serializer\Normalizer\DenormalizerInterface>, maybe add an additional type check?

        $this->expectException(InvalidArgumentException::class);
        $this->denormalizer->denormalize([], \stdClass::class);
    }

    public function testSetDenormalizerWithNoSerializer(): void
    {
        $this->expectException(InvalidArgumentException::class);
        $this->denormalizer->setDenormalizer($this->createMock(DenormalizerInterface::class));

$this->createMock(\Symfony\Component\Serializer\Normalizer\DenormalizerInterface::class) is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<Symfony\Component\Serializer\Normalizer\DenormalizerInterface>.

    }

    public function testDenormalize(): void
    {
        $this->denormalizer->setDenormalizer($this->inner);

It seems like $this->inner can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, Lamoda\IsmpClient\Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizer::setDenormalizer() does only seem to accept object<Symfony\Component\Serializer\Normalizer\DenormalizerInterface>, maybe add an additional type check?

        $originalBodyData = [
            'some_new_crpt_field' => true,
            'document_description' => 'description',
            'products' => [
                [
                    'uit_code' => '010464005741102021PMRanDom32406404',
                    'product_cost' => 42,
                    'product_tax' => 1.1,
                    'product_description' => 'product description 2'
                ],
                [
                    'uit_code' => '010RanDom463007357256021c140640422',
                    'product_cost' => 42,
                    'product_tax' => 1.1,
                    'product_description' => 'product description 2'
                ],
            ]
        ];
        $expectedResult = new Body();
        $property = new \ReflectionProperty(Body::class, 'originalString');
        $property->setAccessible(true);
        $property->setValue($expectedResult, json_encode($originalBodyData));
        $property = new \ReflectionProperty(Body::class, 'documentDescription');
        $property->setAccessible(true);
        $property->setValue($expectedResult, 'description');

        $this->inner->expects($this->once())

The method expects does only exist in PHPUnit\Framework\MockObject\MockObject, but not in Symfony\Component\Serializer\Normalizer\DenormalizerInterface.

            ->method('serialize')
            ->with($originalBodyData, null, [])
            ->willReturn($originalBodyData);
        $enrichedOriginalBodyData = array_merge($originalBodyData, ['original_string' => $originalBodyData]);
        $this->inner->expects($this->once())
            ->method('denormalize')
            ->with($enrichedOriginalBodyData, Body::class, null, [])
            ->willReturn($expectedResult);

        $result = $this->denormalizer->denormalize(
            $originalBodyData,
            Body::class
        );

        $this->assertEquals($expectedResult, $result);
    }

    public function testHasCacheableSupportsMethod(): void
    {
        $this->denormalizer->setDenormalizer($this->inner);

It seems like $this->inner can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, Lamoda\IsmpClient\Impl\Serializer\V4\FacadeDocBodyResponseBodyDenormalizer::setDenormalizer() does only seem to accept object<Symfony\Component\Serializer\Normalizer\DenormalizerInterface>, maybe add an additional type check?

        $result = $this->denormalizer->hasCacheableSupportsMethod();
        $this->assertFalse($result);
    }
}