14500959057

Committed 16 Apr 2025 07:29PM UTC coverage: 8.532% (+0.3%) from 8.189%

Build # 14500959057

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Use `Type` of `TypeInfo` instead of `PropertyInfo` (#6979)

Co-authored-by: soyuka <soyuka@users.noreply.github.com>

scopes: metadata, doctrine, json-schema

Run Details

300 of 616 new or added lines in 25 files covered. (48.7%)

285 existing lines in 18 files now uncovered.

13513 of 158381 relevant lines covered (8.53%)

22.97 hits per line

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

0.0

/src/Metadata/Tests/Property/Factory/SerializerPropertyMetadataFactoryTest.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\Metadata\Tests\Property\Factory;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Metadata\Property\Factory\SerializerPropertyMetadataFactory;
use ApiPlatform\Metadata\ResourceClassResolverInterface;
use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\Dummy;
use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\DummyCar;
use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\RelatedDummy;
use ApiPlatform\Metadata\Tests\Fixtures\DummyIgnoreProperty;
use PHPUnit\Framework\TestCase;
use Prophecy\PhpUnit\ProphecyTrait;
use Symfony\Component\Serializer\Mapping\AttributeMetadata as SerializerAttributeMetadata;
use Symfony\Component\Serializer\Mapping\ClassMetadata as SerializerClassMetadata;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface as SerializerClassMetadataFactoryInterface;
use Symfony\Component\TypeInfo\Type;

class SerializerPropertyMetadataFactoryTest extends TestCase
{
    use ProphecyTrait;

    public static function groupsProvider(): array
    {
        return [
            [['dummy_read'], ['dummy_write']],
            ['dummy_read', 'dummy_write'],
        ];
    }

    #[\PHPUnit\Framework\Attributes\DataProvider('groupsProvider')]
    public function testCreate($readGroups, $writeGroups): void
    {
        $serializerClassMetadataFactoryProphecy = $this->prophesize(SerializerClassMetadataFactoryInterface::class);
        $dummySerializerClassMetadata = new SerializerClassMetadata(Dummy::class);
        $fooSerializerAttributeMetadata = new SerializerAttributeMetadata('foo');
        $fooSerializerAttributeMetadata->addGroup('dummy_read');
        $fooSerializerAttributeMetadata->addGroup('dummy_write');
        $dummySerializerClassMetadata->addAttributeMetadata($fooSerializerAttributeMetadata);
        $relatedDummySerializerAttributeMetadata = new SerializerAttributeMetadata('relatedDummy');
        $relatedDummySerializerAttributeMetadata->addGroup('dummy_read');
        $relatedDummySerializerAttributeMetadata->addGroup('dummy_write');
        $dummySerializerClassMetadata->addAttributeMetadata($relatedDummySerializerAttributeMetadata);
        $nameConvertedSerializerAttributeMetadata = new SerializerAttributeMetadata('nameConverted');
        $dummySerializerClassMetadata->addAttributeMetadata($nameConvertedSerializerAttributeMetadata);
        $serializerClassMetadataFactoryProphecy->getMetadataFor(Dummy::class)->willReturn($dummySerializerClassMetadata);
        $relatedDummySerializerClassMetadata = new SerializerClassMetadata(RelatedDummy::class);
        $nameSerializerAttributeMetadata = new SerializerAttributeMetadata('name');
        $nameSerializerAttributeMetadata->addGroup('dummy_read');
        $relatedDummySerializerClassMetadata->addAttributeMetadata($nameSerializerAttributeMetadata);
        $serializerClassMetadataFactoryProphecy->getMetadataFor(RelatedDummy::class)->willReturn($relatedDummySerializerClassMetadata);
        $dummyCarSerializerClassMetadata = new SerializerClassMetadata(DummyCar::class);
        $nameSerializerAttributeMetadata = new SerializerAttributeMetadata('name');
        $nameSerializerAttributeMetadata->addGroup('dummy_car_read');
        $nameSerializerAttributeMetadata->addGroup('dummy_write');
        $dummyCarSerializerClassMetadata->addAttributeMetadata($nameSerializerAttributeMetadata);
        $serializerClassMetadataFactoryProphecy->getMetadataFor(DummyCar::class)->willReturn($dummyCarSerializerClassMetadata);

        $context = ['normalization_groups' => $readGroups, 'denormalization_groups' => $writeGroups];

        $decoratedProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $fooPropertyMetadata = (new ApiProperty())
            ->withNativeType(Type::nullable(Type::array())) // @phpstan-ignore-line
            ->withReadable(false)
            ->withWritable(true);
        $decoratedProphecy->create(Dummy::class, 'foo', $context)->willReturn($fooPropertyMetadata);
        $relatedDummyPropertyMetadata = (new ApiProperty())
            ->withNativeType(Type::nullable(Type::object(RelatedDummy::class)));
        $decoratedProphecy->create(Dummy::class, 'relatedDummy', $context)->willReturn($relatedDummyPropertyMetadata);
        $nameConvertedPropertyMetadata = (new ApiProperty())
            ->withNativeType(Type::nullable(Type::string())); // @phpstan-ignore-line
        $decoratedProphecy->create(Dummy::class, 'nameConverted', $context)->willReturn($nameConvertedPropertyMetadata);

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

        $serializerPropertyMetadataFactory = new SerializerPropertyMetadataFactory($serializerClassMetadataFactoryProphecy->reveal(), $decoratedProphecy->reveal(), $resourceClassResolverProphecy->reveal());

        $actual = [];
        $actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'foo', $context);
        $actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'relatedDummy', $context);
        $actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'nameConverted', $context);

        $this->assertInstanceOf(ApiProperty::class, $actual[0]);
        $this->assertFalse($actual[0]->isReadable());
        $this->assertTrue($actual[0]->isWritable());

        $this->assertInstanceOf(ApiProperty::class, $actual[1]);
        $this->assertTrue($actual[1]->isReadable());
        $this->assertTrue($actual[1]->isWritable());
        $this->assertTrue($actual[1]->isReadableLink());
        $this->assertFalse($actual[1]->isWritableLink());

        $this->assertInstanceOf(ApiProperty::class, $actual[2]);
        $this->assertFalse($actual[2]->isReadable());
        $this->assertFalse($actual[2]->isWritable());
    }

    public function testCreateWithIgnoredProperty(): void
    {
        $ignoredSerializerAttributeMetadata = new SerializerAttributeMetadata('ignored');
        $ignoredSerializerAttributeMetadata->addGroup('dummy');
        $ignoredSerializerAttributeMetadata->addGroup('dummy');
        $ignoredSerializerAttributeMetadata->setIgnore(true);

        $dummyIgnorePropertySerializerClassMetadata = new SerializerClassMetadata(DummyIgnoreProperty::class);
        $dummyIgnorePropertySerializerClassMetadata->addAttributeMetadata($ignoredSerializerAttributeMetadata);

        $serializerClassMetadataFactoryProphecy = $this->prophesize(SerializerClassMetadataFactoryInterface::class);
        $serializerClassMetadataFactoryProphecy->getMetadataFor(DummyIgnoreProperty::class)->willReturn($dummyIgnorePropertySerializerClassMetadata);

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

        $ignoredPropertyMetadata = (new ApiProperty())->withNativeType(Type::nullable(Type::string())); // @phpstan-ignore-line

        $options = [
            'normalization_groups' => ['dummy'],
            'denormalization_groups' => ['dummy'],
        ];

        $decoratedProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $decoratedProphecy->create(DummyIgnoreProperty::class, 'ignored', $options)->willReturn($ignoredPropertyMetadata);

        $serializerPropertyMetadataFactory = new SerializerPropertyMetadataFactory(
            $serializerClassMetadataFactoryProphecy->reveal(),
            $decoratedProphecy->reveal(),
            $resourceClassResolverProphecy->reveal()
        );

        $result = $serializerPropertyMetadataFactory->create(DummyIgnoreProperty::class, 'ignored', $options);

        self::assertFalse($result->isReadable());
        self::assertFalse($result->isWritable());
    }
}

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\Metadata\Tests\Property\Factory;
15
16	use ApiPlatform\Metadata\ApiProperty;
17	use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
18	use ApiPlatform\Metadata\Property\Factory\SerializerPropertyMetadataFactory;
19	use ApiPlatform\Metadata\ResourceClassResolverInterface;
20	use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\Dummy;
21	use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\DummyCar;
22	use ApiPlatform\Metadata\Tests\Fixtures\ApiResource\RelatedDummy;
23	use ApiPlatform\Metadata\Tests\Fixtures\DummyIgnoreProperty;
24	use PHPUnit\Framework\TestCase;
25	use Prophecy\PhpUnit\ProphecyTrait;
26	use Symfony\Component\Serializer\Mapping\AttributeMetadata as SerializerAttributeMetadata;
27	use Symfony\Component\Serializer\Mapping\ClassMetadata as SerializerClassMetadata;
28	use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface as SerializerClassMetadataFactoryInterface;
29	use Symfony\Component\TypeInfo\Type;
30
31	class SerializerPropertyMetadataFactoryTest extends TestCase
32	{
33	use ProphecyTrait;
34
35	public static function groupsProvider(): array
36	{
37	return [	×
38	[['dummy_read'], ['dummy_write']],	×
39	['dummy_read', 'dummy_write'],	×
40	];	×
41	}
42
43	#[\PHPUnit\Framework\Attributes\DataProvider('groupsProvider')]
44	public function testCreate($readGroups, $writeGroups): void
45	{
46	$serializerClassMetadataFactoryProphecy = $this->prophesize(SerializerClassMetadataFactoryInterface::class);	×
47	$dummySerializerClassMetadata = new SerializerClassMetadata(Dummy::class);	×
48	$fooSerializerAttributeMetadata = new SerializerAttributeMetadata('foo');	×
49	$fooSerializerAttributeMetadata->addGroup('dummy_read');	×
50	$fooSerializerAttributeMetadata->addGroup('dummy_write');	×
51	$dummySerializerClassMetadata->addAttributeMetadata($fooSerializerAttributeMetadata);	×
52	$relatedDummySerializerAttributeMetadata = new SerializerAttributeMetadata('relatedDummy');	×
53	$relatedDummySerializerAttributeMetadata->addGroup('dummy_read');	×
54	$relatedDummySerializerAttributeMetadata->addGroup('dummy_write');	×
55	$dummySerializerClassMetadata->addAttributeMetadata($relatedDummySerializerAttributeMetadata);	×
56	$nameConvertedSerializerAttributeMetadata = new SerializerAttributeMetadata('nameConverted');	×
57	$dummySerializerClassMetadata->addAttributeMetadata($nameConvertedSerializerAttributeMetadata);	×
58	$serializerClassMetadataFactoryProphecy->getMetadataFor(Dummy::class)->willReturn($dummySerializerClassMetadata);	×
59	$relatedDummySerializerClassMetadata = new SerializerClassMetadata(RelatedDummy::class);	×
60	$nameSerializerAttributeMetadata = new SerializerAttributeMetadata('name');	×
61	$nameSerializerAttributeMetadata->addGroup('dummy_read');	×
62	$relatedDummySerializerClassMetadata->addAttributeMetadata($nameSerializerAttributeMetadata);	×
63	$serializerClassMetadataFactoryProphecy->getMetadataFor(RelatedDummy::class)->willReturn($relatedDummySerializerClassMetadata);	×
64	$dummyCarSerializerClassMetadata = new SerializerClassMetadata(DummyCar::class);	×
65	$nameSerializerAttributeMetadata = new SerializerAttributeMetadata('name');	×
66	$nameSerializerAttributeMetadata->addGroup('dummy_car_read');	×
67	$nameSerializerAttributeMetadata->addGroup('dummy_write');	×
68	$dummyCarSerializerClassMetadata->addAttributeMetadata($nameSerializerAttributeMetadata);	×
69	$serializerClassMetadataFactoryProphecy->getMetadataFor(DummyCar::class)->willReturn($dummyCarSerializerClassMetadata);	×
70
71	$context = ['normalization_groups' => $readGroups, 'denormalization_groups' => $writeGroups];	×
72
73	$decoratedProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
74	$fooPropertyMetadata = (new ApiProperty())	×
NEW 75	->withNativeType(Type::nullable(Type::array())) // @phpstan-ignore-line	×
76	->withReadable(false)	×
77	->withWritable(true);	×
78	$decoratedProphecy->create(Dummy::class, 'foo', $context)->willReturn($fooPropertyMetadata);	×
79	$relatedDummyPropertyMetadata = (new ApiProperty())	×
NEW 80	->withNativeType(Type::nullable(Type::object(RelatedDummy::class)));	×
81	$decoratedProphecy->create(Dummy::class, 'relatedDummy', $context)->willReturn($relatedDummyPropertyMetadata);	×
82	$nameConvertedPropertyMetadata = (new ApiProperty())	×
NEW 83	->withNativeType(Type::nullable(Type::string())); // @phpstan-ignore-line	×
84	$decoratedProphecy->create(Dummy::class, 'nameConverted', $context)->willReturn($nameConvertedPropertyMetadata);	×
85
86	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
87	$resourceClassResolverProphecy->isResourceClass(Dummy::class)->willReturn(true);	×
88	$resourceClassResolverProphecy->isResourceClass(RelatedDummy::class)->willReturn(true);	×
89	$resourceClassResolverProphecy->getResourceClass(null, RelatedDummy::class)->willReturn(RelatedDummy::class);	×
90
91	$serializerPropertyMetadataFactory = new SerializerPropertyMetadataFactory($serializerClassMetadataFactoryProphecy->reveal(), $decoratedProphecy->reveal(), $resourceClassResolverProphecy->reveal());	×
92
93	$actual = [];	×
94	$actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'foo', $context);	×
95	$actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'relatedDummy', $context);	×
96	$actual[] = $serializerPropertyMetadataFactory->create(Dummy::class, 'nameConverted', $context);	×
97
98	$this->assertInstanceOf(ApiProperty::class, $actual[0]);	×
99	$this->assertFalse($actual[0]->isReadable());	×
100	$this->assertTrue($actual[0]->isWritable());	×
101
102	$this->assertInstanceOf(ApiProperty::class, $actual[1]);	×
103	$this->assertTrue($actual[1]->isReadable());	×
104	$this->assertTrue($actual[1]->isWritable());	×
105	$this->assertTrue($actual[1]->isReadableLink());	×
106	$this->assertFalse($actual[1]->isWritableLink());	×
107
108	$this->assertInstanceOf(ApiProperty::class, $actual[2]);	×
109	$this->assertFalse($actual[2]->isReadable());	×
110	$this->assertFalse($actual[2]->isWritable());	×
111	}
112
113	public function testCreateWithIgnoredProperty(): void
114	{
115	$ignoredSerializerAttributeMetadata = new SerializerAttributeMetadata('ignored');	×
116	$ignoredSerializerAttributeMetadata->addGroup('dummy');	×
117	$ignoredSerializerAttributeMetadata->addGroup('dummy');	×
118	$ignoredSerializerAttributeMetadata->setIgnore(true);	×
119
120	$dummyIgnorePropertySerializerClassMetadata = new SerializerClassMetadata(DummyIgnoreProperty::class);	×
121	$dummyIgnorePropertySerializerClassMetadata->addAttributeMetadata($ignoredSerializerAttributeMetadata);	×
122
123	$serializerClassMetadataFactoryProphecy = $this->prophesize(SerializerClassMetadataFactoryInterface::class);	×
124	$serializerClassMetadataFactoryProphecy->getMetadataFor(DummyIgnoreProperty::class)->willReturn($dummyIgnorePropertySerializerClassMetadata);	×
125
126	$resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);	×
127	$resourceClassResolverProphecy->isResourceClass(DummyIgnoreProperty::class)->willReturn(true);	×
128
NEW 129	$ignoredPropertyMetadata = (new ApiProperty())->withNativeType(Type::nullable(Type::string())); // @phpstan-ignore-line	×
130
131	$options = [	×
132	'normalization_groups' => ['dummy'],	×
133	'denormalization_groups' => ['dummy'],	×
134	];	×
135
136	$decoratedProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
137	$decoratedProphecy->create(DummyIgnoreProperty::class, 'ignored', $options)->willReturn($ignoredPropertyMetadata);	×
138
139	$serializerPropertyMetadataFactory = new SerializerPropertyMetadataFactory(	×
140	$serializerClassMetadataFactoryProphecy->reveal(),	×
141	$decoratedProphecy->reveal(),	×
142	$resourceClassResolverProphecy->reveal()	×
143	);	×
144
145	$result = $serializerPropertyMetadataFactory->create(DummyIgnoreProperty::class, 'ignored', $options);	×
146
147	self::assertFalse($result->isReadable());	×
148	self::assertFalse($result->isWritable());	×
149	}
150	}

api-platform / core / 14500959057

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