Impl\Serializer\FacadeDocBodyResponseBodyDenormalizerTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	130
Duplicated Lines	10.77 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

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

<?php

namespace Impl\Serializer;

use Lamoda\IsmpClient\Impl\Serializer\FacadeDocBodyResponseBodyDenormalizer;
use Lamoda\IsmpClient\V3\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
{
    /**
     * @var FacadeDocBodyResponseBodyDenormalizer
     */
    private $denormalizer;
    /**
     * @var MockObject|DenormalizerInterface
     */
    private $inner;

    protected function setUp(): void
    {
        $this->inner = $this->getMockBuilder(DenormalizerInterface::class)

The method PHPUnit\Framework\MockObject\MockBuilder::setMethods() has been deprecated with message: https://github.com/sebastianbergmann/phpunit/pull/3687

            ->setMethods(['serialize', 'denormalize', 'supportsDenormalization'])
            ->getMock();
        $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 method seems to be duplicated in your project.

    {
        $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\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 method seems to be duplicated in your project.

    {
        $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\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 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\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\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);
    }
}