7274872202

Committed 20 Dec 2023 11:43AM UTC coverage: 37.396% (-0.08%) from 37.471%

Build # 7274872202

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #6060 from soyuka/merge-32b

Merge 3.1

Run Details

1 of 94 new or added lines in 6 files covered. (1.06%)

4 existing lines in 2 files now uncovered.

10338 of 27645 relevant lines covered (37.4%)

28.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Serializer/Tests/ItemNormalizerTest.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Serializer\Tests;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Exception\InvalidArgumentException;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\IriConverterInterface;
use ApiPlatform\Metadata\Link;
use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Metadata\Property\PropertyNameCollection;
use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
use ApiPlatform\Metadata\ResourceClassResolverInterface;
use ApiPlatform\Metadata\UrlGeneratorInterface;
use ApiPlatform\Serializer\ItemNormalizer;
use ApiPlatform\Serializer\Tests\Fixtures\ApiResource\Dummy;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\PhpUnit\ProphecyTrait;
use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\SerializerInterface;

/**
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
class ItemNormalizerTest extends TestCase
{
    use ExpectDeprecationTrait;
    use ProphecyTrait;

    /**
     * @group legacy
     */
    public function testSupportNormalization(): void
    {
        $std = new \stdClass();
        $dummy = new Dummy();
        $dummy->setDescription('hello');

        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);
        $resourceClassResolverProphecy->isResourceClass(\stdClass::class)->willReturn(false);

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );

        $this->assertTrue($normalizer->supportsNormalization($dummy));
        $this->assertTrue($normalizer->supportsNormalization($dummy));
        $this->assertFalse($normalizer->supportsNormalization($std));

        $this->assertTrue($normalizer->supportsDenormalization($dummy, Dummy::class));
        $this->assertTrue($normalizer->supportsDenormalization($dummy, Dummy::class));
        $this->assertFalse($normalizer->supportsDenormalization($std, \stdClass::class));
        $this->assertSame(['object' => true], $normalizer->getSupportedTypes('any'));

        if (!method_exists(Serializer::class, 'getSupportedTypes')) {
            $this->assertTrue($normalizer->hasCacheableSupportsMethod());
        }
    }

    public function testNormalize(): void
    {
        $dummy = new Dummy();
        $dummy->setName('hello');

        $propertyNameCollection = new PropertyNameCollection(['name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $propertyMetadata = (new ApiProperty())->withReadable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata);

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
        $iriConverterProphecy->getIriFromResource($dummy, Argument::cetera())->willReturn('/dummies/1');

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass($dummy, null)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(NormalizerInterface::class);
        $serializerProphecy->normalize('hello', null, Argument::type('array'))->willReturn('hello');

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertEquals(['name' => 'hello'], $normalizer->normalize($dummy, null, ['resources' => []]));
    }

    public function testDenormalize(): void
    {
        $context = ['resource_class' => Dummy::class, 'api_allow_update' => true];

        $propertyNameCollection = new PropertyNameCollection(['name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();

        $propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);
        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello'], Dummy::class, null, $context));
    }

    public function testDenormalizeWithIri(): void
    {
        $context = ['resource_class' => Dummy::class, 'api_allow_update' => true];

        $propertyNameCollection = new PropertyNameCollection(['id', 'name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();

        $propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'id', [])->willReturn($propertyMetadata)->shouldBeCalled();
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
        $iriConverterProphecy->getResourceFromIri('/dummies/12', ['resource_class' => Dummy::class, 'api_allow_update' => true, 'fetch_data' => true])->shouldBeCalled();

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['id' => '/dummies/12', 'name' => 'hello'], Dummy::class, null, $context));
    }

    public function testDenormalizeWithIdAndUpdateNotAllowed(): void
    {
        $this->expectException(NotNormalizableValueException::class);
        $this->expectExceptionMessage('Update is not allowed for this operation.');

        $context = ['resource_class' => Dummy::class, 'api_allow_update' => false];

        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);

        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());
        $normalizer->denormalize(['id' => '12', 'name' => 'hello'], Dummy::class, null, $context);
    }

    public function testDenormalizeWithDefinedIri(): void
    {
        $dummy = new Dummy();
        $dummy->setName('hello');

        $propertyNameCollection = new PropertyNameCollection(['name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $propertyMetadata = (new ApiProperty())->withReadable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata);

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
        $iriConverterProphecy->getIriFromResource($dummy)->shouldNotBeCalled();

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass($dummy, null)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(NormalizerInterface::class);
        $serializerProphecy->normalize('hello', null, Argument::type('array'))->willReturn('hello');

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertEquals(['name' => 'hello'], $normalizer->normalize($dummy, null, ['resources' => [], 'iri' => '/custom']));
    }

    public function testDenormalizeWithIdAndNoResourceClass(): void
    {
        $context = [];

        $propertyNameCollection = new PropertyNameCollection(['id', 'name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();

        $propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'id', [])->willReturn($propertyMetadata)->shouldBeCalled();
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);

        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $object = $normalizer->denormalize(['id' => '42', 'name' => 'hello'], Dummy::class, null, $context);
        $this->assertInstanceOf(Dummy::class, $object);
        $this->assertSame('42', $object->getId());
        $this->assertSame('hello', $object->getName());
    }

    public function testDenormalizeWithWrongIdAndNoResourceMetadataFactory(): void
    {
        $this->expectException(InvalidArgumentException::class);
        $context = ['resource_class' => Dummy::class, 'api_allow_update' => true];

        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);

        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
        $iriConverterProphecy->getResourceFromIri('fail', $context + ['fetch_data' => true])->willThrow(new InvalidArgumentException());

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);
        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello', 'id' => 'fail'], Dummy::class, null, $context));
    }

    public function testDenormalizeWithWrongId(): void
    {
        $context = ['resource_class' => Dummy::class, 'api_allow_update' => true];
        $operation = new Get(uriVariables: ['id' => new Link(identifiers: ['id'], parameterName: 'id')]);
        $obj = new Dummy();

        $propertyNameCollection = new PropertyNameCollection(['name']);
        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();

        $propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);
        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();

        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
        $iriConverterProphecy->getResourceFromIri('fail', $context + ['fetch_data' => true])->willThrow(new InvalidArgumentException());
        $iriConverterProphecy->getIriFromResource(Dummy::class, UrlGeneratorInterface::ABS_PATH, $operation, ['uri_variables' => ['id' => 'fail']])->willReturn('/dummies/fail');
        $iriConverterProphecy->getResourceFromIri('/dummies/fail', $context + ['fetch_data' => true])->willReturn($obj);

        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
        $resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->getResourceClass($obj, Dummy::class)->willReturn(Dummy::class);
        $resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);

        $resourceMetadataCollectionFactory = $this->prophesize(ResourceMetadataCollectionFactoryInterface::class);
        $resourceMetadataCollectionFactory->create(Dummy::class)->willReturn(new ResourceMetadataCollection(Dummy::class, [
            new ApiResource(operations: [$operation]),
        ]));

        $serializerProphecy = $this->prophesize(SerializerInterface::class);
        $serializerProphecy->willImplement(DenormalizerInterface::class);
        $normalizer = new ItemNormalizer(
            $propertyNameCollectionFactoryProphecy->reveal(),
            $propertyMetadataFactoryProphecy->reveal(),
            $iriConverterProphecy->reveal(),
            $resourceClassResolverProphecy->reveal(),
            null,
            null,
            null,
            null,
            $resourceMetadataCollectionFactory->reveal()
        );
        $normalizer->setSerializer($serializerProphecy->reveal());

        $this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello', 'id' => 'fail'], Dummy::class, null, $context));
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Serializer\Tests;
15
16	use ApiPlatform\Metadata\ApiProperty;
17	use ApiPlatform\Metadata\ApiResource;
18	use ApiPlatform\Metadata\Exception\InvalidArgumentException;
19	use ApiPlatform\Metadata\Get;
20	use ApiPlatform\Metadata\IriConverterInterface;
21	use ApiPlatform\Metadata\Link;
22	use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
23	use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
24	use ApiPlatform\Metadata\Property\PropertyNameCollection;
25	use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
26	use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
27	use ApiPlatform\Metadata\ResourceClassResolverInterface;
28	use ApiPlatform\Metadata\UrlGeneratorInterface;
29	use ApiPlatform\Serializer\ItemNormalizer;
30	use ApiPlatform\Serializer\Tests\Fixtures\ApiResource\Dummy;
31	use PHPUnit\Framework\TestCase;
32	use Prophecy\Argument;
33	use Prophecy\PhpUnit\ProphecyTrait;
34	use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
35	use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
36	use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
37	use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
38	use Symfony\Component\Serializer\Serializer;
39	use Symfony\Component\Serializer\SerializerInterface;
40
41	/**
42	* @author Kévin Dunglas <dunglas@gmail.com>
43	*/
44	class ItemNormalizerTest extends TestCase
45	{
46	use ExpectDeprecationTrait;
47	use ProphecyTrait;
48
49	/**
50	* @group legacy
51	*/
52	public function testSupportNormalization(): void
53	{
54	$std = new \stdClass();	×
55	$dummy = new Dummy();	×
56	$dummy->setDescription('hello');	×
57
58	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
59	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
60	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
61
62	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
63	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
64	$resourceClassResolverProphecy->isResourceClass(\stdClass::class)->willReturn(false);	×
65
66	$normalizer = new ItemNormalizer(	×
67	$propertyNameCollectionFactoryProphecy->reveal(),	×
68	$propertyMetadataFactoryProphecy->reveal(),	×
69	$iriConverterProphecy->reveal(),	×
70	$resourceClassResolverProphecy->reveal()	×
71	);	×
72
73	$this->assertTrue($normalizer->supportsNormalization($dummy));	×
74	$this->assertTrue($normalizer->supportsNormalization($dummy));	×
75	$this->assertFalse($normalizer->supportsNormalization($std));	×
76
77	$this->assertTrue($normalizer->supportsDenormalization($dummy, Dummy::class));	×
78	$this->assertTrue($normalizer->supportsDenormalization($dummy, Dummy::class));	×
79	$this->assertFalse($normalizer->supportsDenormalization($std, \stdClass::class));	×
80	$this->assertSame(['object' => true], $normalizer->getSupportedTypes('any'));	×
81
82	if (!method_exists(Serializer::class, 'getSupportedTypes')) {	×
83	$this->assertTrue($normalizer->hasCacheableSupportsMethod());	×
84	}
85	}
86
87	public function testNormalize(): void
88	{
89	$dummy = new Dummy();	×
90	$dummy->setName('hello');	×
91
92	$propertyNameCollection = new PropertyNameCollection(['name']);	×
93	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
94	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection);	×
95
96	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
97	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
98
99	$propertyMetadata = (new ApiProperty())->withReadable(true);	×
100	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
101	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata);	×
102
103	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
104	$iriConverterProphecy->getIriFromResource($dummy, Argument::cetera())->willReturn('/dummies/1');	×
105
106	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
107	$resourceClassResolverProphecy->getResourceClass($dummy, null)->willReturn(Dummy::class);	×
108	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
109	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
110
111	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
112	$serializerProphecy->willImplement(NormalizerInterface::class);	×
113	$serializerProphecy->normalize('hello', null, Argument::type('array'))->willReturn('hello');	×
114
115	$normalizer = new ItemNormalizer(	×
116	$propertyNameCollectionFactoryProphecy->reveal(),	×
117	$propertyMetadataFactoryProphecy->reveal(),	×
118	$iriConverterProphecy->reveal(),	×
119	$resourceClassResolverProphecy->reveal()	×
120	);	×
121	$normalizer->setSerializer($serializerProphecy->reveal());	×
122
123	$this->assertEquals(['name' => 'hello'], $normalizer->normalize($dummy, null, ['resources' => []]));	×
124	}
125
126	public function testDenormalize(): void
127	{
128	$context = ['resource_class' => Dummy::class, 'api_allow_update' => true];	×
129
130	$propertyNameCollection = new PropertyNameCollection(['name']);	×
131	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
132	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();	×
133
134	$propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);	×
135	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
136	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
137
138	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
139
140	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
141	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
142	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
143
144	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
145	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
146	$normalizer = new ItemNormalizer(	×
147	$propertyNameCollectionFactoryProphecy->reveal(),	×
148	$propertyMetadataFactoryProphecy->reveal(),	×
149	$iriConverterProphecy->reveal(),	×
150	$resourceClassResolverProphecy->reveal()	×
151	);	×
152	$normalizer->setSerializer($serializerProphecy->reveal());	×
153
154	$this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello'], Dummy::class, null, $context));	×
155	}
156
157	public function testDenormalizeWithIri(): void
158	{
159	$context = ['resource_class' => Dummy::class, 'api_allow_update' => true];	×
160
161	$propertyNameCollection = new PropertyNameCollection(['id', 'name']);	×
162	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
163	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();	×
164
165	$propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);	×
166	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
167	$propertyMetadataFactoryProphecy->create(Dummy::class, 'id', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
168	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
169
170	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
171	$iriConverterProphecy->getResourceFromIri('/dummies/12', ['resource_class' => Dummy::class, 'api_allow_update' => true, 'fetch_data' => true])->shouldBeCalled();	×
172
173	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
174	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
175	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
176
177	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
178	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
179
180	$normalizer = new ItemNormalizer(	×
181	$propertyNameCollectionFactoryProphecy->reveal(),	×
182	$propertyMetadataFactoryProphecy->reveal(),	×
183	$iriConverterProphecy->reveal(),	×
184	$resourceClassResolverProphecy->reveal()	×
185	);	×
186	$normalizer->setSerializer($serializerProphecy->reveal());	×
187
188	$this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['id' => '/dummies/12', 'name' => 'hello'], Dummy::class, null, $context));	×
189	}
190
191	public function testDenormalizeWithIdAndUpdateNotAllowed(): void
192	{
193	$this->expectException(NotNormalizableValueException::class);	×
194	$this->expectExceptionMessage('Update is not allowed for this operation.');	×
195
196	$context = ['resource_class' => Dummy::class, 'api_allow_update' => false];	×
197
198	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
199
200	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
201
202	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
203
204	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
205
206	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
207	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
208
209	$normalizer = new ItemNormalizer(	×
210	$propertyNameCollectionFactoryProphecy->reveal(),	×
211	$propertyMetadataFactoryProphecy->reveal(),	×
212	$iriConverterProphecy->reveal(),	×
213	$resourceClassResolverProphecy->reveal()	×
214	);	×
215	$normalizer->setSerializer($serializerProphecy->reveal());	×
216	$normalizer->denormalize(['id' => '12', 'name' => 'hello'], Dummy::class, null, $context);	×
217	}
218
219	public function testDenormalizeWithDefinedIri(): void
220	{
221	$dummy = new Dummy();	×
222	$dummy->setName('hello');	×
223
224	$propertyNameCollection = new PropertyNameCollection(['name']);	×
225	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
226	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection);	×
227
228	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
229	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
230
231	$propertyMetadata = (new ApiProperty())->withReadable(true);	×
232	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
233	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata);	×
234
235	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
236	$iriConverterProphecy->getIriFromResource($dummy)->shouldNotBeCalled();	×
237
238	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
239	$resourceClassResolverProphecy->getResourceClass($dummy, null)->willReturn(Dummy::class);	×
240	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
241	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
242
243	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
244	$serializerProphecy->willImplement(NormalizerInterface::class);	×
245	$serializerProphecy->normalize('hello', null, Argument::type('array'))->willReturn('hello');	×
246
247	$normalizer = new ItemNormalizer(	×
248	$propertyNameCollectionFactoryProphecy->reveal(),	×
249	$propertyMetadataFactoryProphecy->reveal(),	×
250	$iriConverterProphecy->reveal(),	×
251	$resourceClassResolverProphecy->reveal()	×
252	);	×
253	$normalizer->setSerializer($serializerProphecy->reveal());	×
254
255	$this->assertEquals(['name' => 'hello'], $normalizer->normalize($dummy, null, ['resources' => [], 'iri' => '/custom']));	×
256	}
257
258	public function testDenormalizeWithIdAndNoResourceClass(): void
259	{
260	$context = [];	×
261
262	$propertyNameCollection = new PropertyNameCollection(['id', 'name']);	×
263	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
264	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();	×
265
266	$propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);	×
267	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
268	$propertyMetadataFactoryProphecy->create(Dummy::class, 'id', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
269	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
270
271	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
272
273	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
274	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
275	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
276
277	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
278	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
279
280	$normalizer = new ItemNormalizer(	×
281	$propertyNameCollectionFactoryProphecy->reveal(),	×
282	$propertyMetadataFactoryProphecy->reveal(),	×
283	$iriConverterProphecy->reveal(),	×
284	$resourceClassResolverProphecy->reveal()	×
285	);	×
286	$normalizer->setSerializer($serializerProphecy->reveal());	×
287
288	$object = $normalizer->denormalize(['id' => '42', 'name' => 'hello'], Dummy::class, null, $context);	×
289	$this->assertInstanceOf(Dummy::class, $object);	×
290	$this->assertSame('42', $object->getId());	×
291	$this->assertSame('hello', $object->getName());	×
292	}
293
294	public function testDenormalizeWithWrongIdAndNoResourceMetadataFactory(): void
295	{
NEW 296	$this->expectException(InvalidArgumentException::class);	×
NEW 297	$context = ['resource_class' => Dummy::class, 'api_allow_update' => true];	×
298
NEW 299	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
300
NEW 301	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
302
NEW 303	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
NEW 304	$iriConverterProphecy->getResourceFromIri('fail', $context + ['fetch_data' => true])->willThrow(new InvalidArgumentException());	×
305
NEW 306	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
NEW 307	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
NEW 308	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
309
NEW 310	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
NEW 311	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
NEW 312	$normalizer = new ItemNormalizer(	×
NEW 313	$propertyNameCollectionFactoryProphecy->reveal(),	×
NEW 314	$propertyMetadataFactoryProphecy->reveal(),	×
NEW 315	$iriConverterProphecy->reveal(),	×
NEW 316	$resourceClassResolverProphecy->reveal()	×
NEW 317	);	×
NEW 318	$normalizer->setSerializer($serializerProphecy->reveal());	×
319
NEW 320	$this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello', 'id' => 'fail'], Dummy::class, null, $context));	×
321	}
322
323	public function testDenormalizeWithWrongId(): void
324	{
NEW 325	$context = ['resource_class' => Dummy::class, 'api_allow_update' => true];	×
NEW 326	$operation = new Get(uriVariables: ['id' => new Link(identifiers: ['id'], parameterName: 'id')]);	×
NEW 327	$obj = new Dummy();	×
328
NEW 329	$propertyNameCollection = new PropertyNameCollection(['name']);	×
NEW 330	$propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
NEW 331	$propertyNameCollectionFactoryProphecy->create(Dummy::class, [])->willReturn($propertyNameCollection)->shouldBeCalled();	×
332
NEW 333	$propertyMetadata = (new ApiProperty())->withReadable(true)->withWritable(true);	×
NEW 334	$propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
NEW 335	$propertyMetadataFactoryProphecy->create(Dummy::class, 'name', [])->willReturn($propertyMetadata)->shouldBeCalled();	×
336
NEW 337	$iriConverterProphecy = $this->prophesize(IriConverterInterface::class);	×
NEW 338	$iriConverterProphecy->getResourceFromIri('fail', $context + ['fetch_data' => true])->willThrow(new InvalidArgumentException());	×
NEW 339	$iriConverterProphecy->getIriFromResource(Dummy::class, UrlGeneratorInterface::ABS_PATH, $operation, ['uri_variables' => ['id' => 'fail']])->willReturn('/dummies/fail');	×
NEW 340	$iriConverterProphecy->getResourceFromIri('/dummies/fail', $context + ['fetch_data' => true])->willReturn($obj);	×
341
NEW 342	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
NEW 343	$resourceClassResolverProphecy->getResourceClass(null, Dummy::class)->willReturn(Dummy::class);	×
NEW 344	$resourceClassResolverProphecy->getResourceClass($obj, Dummy::class)->willReturn(Dummy::class);	×
NEW 345	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
346
NEW 347	$resourceMetadataCollectionFactory = $this->prophesize(ResourceMetadataCollectionFactoryInterface::class);	×
NEW 348	$resourceMetadataCollectionFactory->create(Dummy::class)->willReturn(new ResourceMetadataCollection(Dummy::class, [	×
NEW 349	new ApiResource(operations: [$operation]),	×
NEW 350	]));	×
351
NEW 352	$serializerProphecy = $this->prophesize(SerializerInterface::class);	×
NEW 353	$serializerProphecy->willImplement(DenormalizerInterface::class);	×
NEW 354	$normalizer = new ItemNormalizer(	×
NEW 355	$propertyNameCollectionFactoryProphecy->reveal(),	×
NEW 356	$propertyMetadataFactoryProphecy->reveal(),	×
NEW 357	$iriConverterProphecy->reveal(),	×
NEW 358	$resourceClassResolverProphecy->reveal(),	×
NEW 359	null,	×
NEW 360	null,	×
NEW 361	null,	×
NEW 362	null,	×
NEW 363	$resourceMetadataCollectionFactory->reveal()	×
NEW 364	);	×
NEW 365	$normalizer->setSerializer($serializerProphecy->reveal());	×
366
NEW 367	$this->assertInstanceOf(Dummy::class, $normalizer->denormalize(['name' => 'hello', 'id' => 'fail'], Dummy::class, null, $context));	×
368	}
369	}

api-platform / core / 7274872202

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous