15069419398

Committed 16 May 2025 01:19PM UTC coverage: 21.832%. First build

Build # 15069419398

Build Type

Pull #6960

github

Committed by

web-flow

Commit Message

Merge 88ff9fb4b into b6080d419

Pull Request Pull Request #6960: feat(json-schema): mutualize json schema between formats

Run Details

0 of 470 new or added lines in 25 files covered. (0.0%)

11116 of 50915 relevant lines covered (21.83%)

29.49 hits per line

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

0.0

/src/Hydra/Tests/JsonSchema/SchemaFactoryTest.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\Hydra\Tests\JsonSchema;

use ApiPlatform\Hydra\JsonSchema\SchemaFactory;
use ApiPlatform\Hydra\Tests\Fixtures\Dummy;
use ApiPlatform\JsonLd\ContextBuilder;
use ApiPlatform\JsonSchema\DefinitionNameFactory;
use ApiPlatform\JsonSchema\Schema;
use ApiPlatform\JsonSchema\SchemaFactory as BaseSchemaFactory;
use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
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 PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\PhpUnit\ProphecyTrait;

class SchemaFactoryTest extends TestCase
{
    use ProphecyTrait;

    private SchemaFactory $schemaFactory;

    protected function setUp(): void
    {
        $resourceMetadataFactoryCollection = $this->prophesize(ResourceMetadataCollectionFactoryInterface::class);
        $resourceMetadataFactoryCollection->create(Dummy::class)->willReturn(
            new ResourceMetadataCollection(Dummy::class, [
                new ApiResource(operations: [
                    'get' => new Get(name: 'get'),
                ]),
            ])
        );

        $propertyNameCollectionFactory = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
        $propertyNameCollectionFactory->create(Dummy::class, ['enable_getter_setter_extraction' => true, 'schema_type' => Schema::TYPE_OUTPUT])->willReturn(new PropertyNameCollection(['id', 'name']));
        $propertyMetadataFactory = $this->prophesize(PropertyMetadataFactoryInterface::class);
        $propertyMetadataFactory->create(Dummy::class, 'id', Argument::type('array'))->willReturn(new ApiProperty(identifier: true));
        $propertyMetadataFactory->create(Dummy::class, 'name', Argument::type('array'))->willReturn(new ApiProperty());

        $definitionNameFactory = new DefinitionNameFactory();

        $baseSchemaFactory = new BaseSchemaFactory(
            resourceMetadataFactory: $resourceMetadataFactoryCollection->reveal(),
            propertyNameCollectionFactory: $propertyNameCollectionFactory->reveal(),
            propertyMetadataFactory: $propertyMetadataFactory->reveal(),
            definitionNameFactory: $definitionNameFactory,
        );

        $this->schemaFactory = new SchemaFactory(
            $baseSchemaFactory,
            [],
            $definitionNameFactory,
            $resourceMetadataFactoryCollection->reveal(),
        );
    }

    public function testBuildSchema(): void
    {
        $resultSchema = $this->schemaFactory->buildSchema(Dummy::class);

        $this->assertTrue($resultSchema->isDefined());
        $this->assertSame('Dummy.jsonld', $resultSchema->getRootDefinitionKey());
    }

    public function testCustomFormatBuildSchema(): void
    {
        $resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'json');

        $this->assertTrue($resultSchema->isDefined());
        $this->assertSame('Dummy', $resultSchema->getRootDefinitionKey());
    }

    public function testHasRootDefinitionKeyBuildSchema(): void
    {
        $resultSchema = $this->schemaFactory->buildSchema(Dummy::class);
        $definitions = $resultSchema->getDefinitions();
        $rootDefinitionKey = $resultSchema->getRootDefinitionKey();

        $this->assertTrue(isset($definitions[$rootDefinitionKey]));
        $this->assertTrue(isset($definitions[$rootDefinitionKey]['allOf'][1]['properties']));
        $this->assertEquals($definitions[$rootDefinitionKey]['allOf'][0], ['$ref' => '#/definitions/HydraItemBaseSchema']);

        $properties = $definitions['HydraItemBaseSchema']['properties'];
        $this->assertArrayHasKey('@context', $properties);
        $this->assertEquals(
            [
                'oneOf' => [
                    ['type' => 'string'],
                    [
                        'type' => 'object',
                        'properties' => [
                            '@vocab' => [
                                'type' => 'string',
                            ],
                            'hydra' => [
                                'type' => 'string',
                                'enum' => [ContextBuilder::HYDRA_NS],
                            ],
                        ],
                        'required' => ['@vocab', 'hydra'],
                        'additionalProperties' => true,
                    ],
                ],
            ],
            $properties['@context']
        );
        $this->assertArrayHasKey('@type', $properties);
        $this->assertArrayHasKey('@id', $properties);
    }

    public function testSchemaTypeBuildSchema(): void
    {
        $resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, new GetCollection());
        $this->assertNull($resultSchema->getRootDefinitionKey());
        $hydraCollectionSchema = $resultSchema['definitions']['HydraCollectionBaseSchema'];
        $properties = $hydraCollectionSchema['properties'];
        $this->assertTrue(isset($properties['hydra:member']));
        $this->assertArrayHasKey('hydra:totalItems', $properties);
        $this->assertArrayHasKey('hydra:view', $properties);
        $this->assertArrayHasKey('hydra:search', $properties);
        $this->assertArrayNotHasKey('@context', $properties);

        $this->assertTrue(isset($properties['hydra:view']));
        $this->assertArrayHasKey('properties', $properties['hydra:view']);
        $this->assertArrayHasKey('hydra:first', $properties['hydra:view']['properties']);
        $this->assertArrayHasKey('hydra:last', $properties['hydra:view']['properties']);
        $this->assertArrayHasKey('hydra:previous', $properties['hydra:view']['properties']);
        $this->assertArrayHasKey('hydra:next', $properties['hydra:view']['properties']);

        $forcedCollection = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, null, null, null, true);
        $this->assertEquals($resultSchema['allOf'][0]['$ref'], $forcedCollection['allOf'][0]['$ref']);
    }

    public function testSchemaTypeBuildSchemaWithoutPrefix(): void
    {
        $resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, new GetCollection(), null, [ContextBuilder::HYDRA_CONTEXT_HAS_PREFIX => false]);
        $this->assertNull($resultSchema->getRootDefinitionKey());
        $hydraCollectionSchema = $resultSchema['definitions']['HydraCollectionBaseSchema'];
        $properties = $hydraCollectionSchema['properties'];
        $this->assertArrayHasKey('totalItems', $properties);
        $this->assertArrayHasKey('view', $properties);
        $this->assertArrayHasKey('search', $properties);
    }
}

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\Hydra\Tests\JsonSchema;
15
16	use ApiPlatform\Hydra\JsonSchema\SchemaFactory;
17	use ApiPlatform\Hydra\Tests\Fixtures\Dummy;
18	use ApiPlatform\JsonLd\ContextBuilder;
19	use ApiPlatform\JsonSchema\DefinitionNameFactory;
20	use ApiPlatform\JsonSchema\Schema;
21	use ApiPlatform\JsonSchema\SchemaFactory as BaseSchemaFactory;
22	use ApiPlatform\Metadata\ApiProperty;
23	use ApiPlatform\Metadata\ApiResource;
24	use ApiPlatform\Metadata\Get;
25	use ApiPlatform\Metadata\GetCollection;
26	use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
27	use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
28	use ApiPlatform\Metadata\Property\PropertyNameCollection;
29	use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
30	use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
31	use PHPUnit\Framework\TestCase;
32	use Prophecy\Argument;
33	use Prophecy\PhpUnit\ProphecyTrait;
34
35	class SchemaFactoryTest extends TestCase
36	{
37	use ProphecyTrait;
38
39	private SchemaFactory $schemaFactory;
40
41	protected function setUp(): void
42	{
43	$resourceMetadataFactoryCollection = $this->prophesize(ResourceMetadataCollectionFactoryInterface::class);	×
44	$resourceMetadataFactoryCollection->create(Dummy::class)->willReturn(	×
45	new ResourceMetadataCollection(Dummy::class, [	×
46	new ApiResource(operations: [	×
47	'get' => new Get(name: 'get'),	×
48	]),	×
49	])	×
50	);	×
51
52	$propertyNameCollectionFactory = $this->prophesize(PropertyNameCollectionFactoryInterface::class);	×
NEW 53	$propertyNameCollectionFactory->create(Dummy::class, ['enable_getter_setter_extraction' => true, 'schema_type' => Schema::TYPE_OUTPUT])->willReturn(new PropertyNameCollection(['id', 'name']));	×
54	$propertyMetadataFactory = $this->prophesize(PropertyMetadataFactoryInterface::class);	×
NEW 55	$propertyMetadataFactory->create(Dummy::class, 'id', Argument::type('array'))->willReturn(new ApiProperty(identifier: true));	×
NEW 56	$propertyMetadataFactory->create(Dummy::class, 'name', Argument::type('array'))->willReturn(new ApiProperty());	×
57
NEW 58	$definitionNameFactory = new DefinitionNameFactory();	×
59
60	$baseSchemaFactory = new BaseSchemaFactory(	×
61	resourceMetadataFactory: $resourceMetadataFactoryCollection->reveal(),	×
62	propertyNameCollectionFactory: $propertyNameCollectionFactory->reveal(),	×
63	propertyMetadataFactory: $propertyMetadataFactory->reveal(),	×
64	definitionNameFactory: $definitionNameFactory,	×
65	);	×
66
NEW 67	$this->schemaFactory = new SchemaFactory(	×
NEW 68	$baseSchemaFactory,	×
NEW 69	[],	×
NEW 70	$definitionNameFactory,	×
NEW 71	$resourceMetadataFactoryCollection->reveal(),	×
NEW 72	);	×
73	}
74
75	public function testBuildSchema(): void
76	{
77	$resultSchema = $this->schemaFactory->buildSchema(Dummy::class);	×
78
79	$this->assertTrue($resultSchema->isDefined());	×
80	$this->assertSame('Dummy.jsonld', $resultSchema->getRootDefinitionKey());	×
81	}
82
83	public function testCustomFormatBuildSchema(): void
84	{
85	$resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'json');	×
86
87	$this->assertTrue($resultSchema->isDefined());	×
88	$this->assertSame('Dummy', $resultSchema->getRootDefinitionKey());	×
89	}
90
91	public function testHasRootDefinitionKeyBuildSchema(): void
92	{
93	$resultSchema = $this->schemaFactory->buildSchema(Dummy::class);	×
94	$definitions = $resultSchema->getDefinitions();	×
95	$rootDefinitionKey = $resultSchema->getRootDefinitionKey();	×
96
97	$this->assertTrue(isset($definitions[$rootDefinitionKey]));	×
NEW 98	$this->assertTrue(isset($definitions[$rootDefinitionKey]['allOf'][1]['properties']));	×
NEW 99	$this->assertEquals($definitions[$rootDefinitionKey]['allOf'][0], ['$ref' => '#/definitions/HydraItemBaseSchema']);	×
100
NEW 101	$properties = $definitions['HydraItemBaseSchema']['properties'];	×
102	$this->assertArrayHasKey('@context', $properties);	×
103	$this->assertEquals(	×
104	[	×
105	'oneOf' => [	×
106	['type' => 'string'],	×
107	[	×
108	'type' => 'object',	×
109	'properties' => [	×
110	'@vocab' => [	×
111	'type' => 'string',	×
112	],	×
113	'hydra' => [	×
114	'type' => 'string',	×
115	'enum' => [ContextBuilder::HYDRA_NS],	×
116	],	×
117	],	×
118	'required' => ['@vocab', 'hydra'],	×
119	'additionalProperties' => true,	×
120	],	×
121	],	×
122	],	×
123	$properties['@context']	×
124	);	×
125	$this->assertArrayHasKey('@type', $properties);	×
126	$this->assertArrayHasKey('@id', $properties);	×
127	}
128
129	public function testSchemaTypeBuildSchema(): void
130	{
131	$resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, new GetCollection());	×
132	$this->assertNull($resultSchema->getRootDefinitionKey());	×
NEW 133	$hydraCollectionSchema = $resultSchema['definitions']['HydraCollectionBaseSchema'];	×
NEW 134	$properties = $hydraCollectionSchema['properties'];	×
NEW 135	$this->assertTrue(isset($properties['hydra:member']));	×
NEW 136	$this->assertArrayHasKey('hydra:totalItems', $properties);	×
NEW 137	$this->assertArrayHasKey('hydra:view', $properties);	×
NEW 138	$this->assertArrayHasKey('hydra:search', $properties);	×
139	$this->assertArrayNotHasKey('@context', $properties);	×
140
NEW 141	$this->assertTrue(isset($properties['hydra:view']));	×
NEW 142	$this->assertArrayHasKey('properties', $properties['hydra:view']);	×
NEW 143	$this->assertArrayHasKey('hydra:first', $properties['hydra:view']['properties']);	×
NEW 144	$this->assertArrayHasKey('hydra:last', $properties['hydra:view']['properties']);	×
NEW 145	$this->assertArrayHasKey('hydra:previous', $properties['hydra:view']['properties']);	×
NEW 146	$this->assertArrayHasKey('hydra:next', $properties['hydra:view']['properties']);	×
147
NEW 148	$forcedCollection = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, null, null, null, true);	×
NEW 149	$this->assertEquals($resultSchema['allOf'][0]['$ref'], $forcedCollection['allOf'][0]['$ref']);	×
150	}
151
152	public function testSchemaTypeBuildSchemaWithoutPrefix(): void
153	{
154	$resultSchema = $this->schemaFactory->buildSchema(Dummy::class, 'jsonld', Schema::TYPE_OUTPUT, new GetCollection(), null, [ContextBuilder::HYDRA_CONTEXT_HAS_PREFIX => false]);	×
155	$this->assertNull($resultSchema->getRootDefinitionKey());	×
NEW 156	$hydraCollectionSchema = $resultSchema['definitions']['HydraCollectionBaseSchema'];	×
NEW 157	$properties = $hydraCollectionSchema['properties'];	×
NEW 158	$this->assertArrayHasKey('totalItems', $properties);	×
NEW 159	$this->assertArrayHasKey('view', $properties);	×
NEW 160	$this->assertArrayHasKey('search', $properties);	×
161	}
162	}

api-platform / core / 15069419398

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