10014117656

Committed 19 Jul 2024 08:44PM UTC coverage: 7.856% (-56.3%) from 64.185%

Build # 10014117656

Build Type

push

github

Committed by

soyuka

Commit Message

Merge branch 'sf/remove-flag'

Run Details

0 of 527 new or added lines in 83 files covered. (0.0%)

10505 existing lines in 362 files now uncovered.

12705 of 161727 relevant lines covered (7.86%)

26.85 hits per line

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

0.0

/src/Symfony/Tests/EventListener/ErrorListenerTest.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\Symfony\Tests\EventListener;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\IdentifiersExtractorInterface;
use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
use ApiPlatform\Metadata\ResourceClassResolverInterface;
use ApiPlatform\State\ApiResource\Error;
use ApiPlatform\Symfony\EventListener\ErrorListener;
use PHPUnit\Framework\TestCase;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\ExceptionEvent;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpKernel\KernelInterface;

class ErrorListenerTest extends TestCase
{
    protected function tearDown(): void
    {
        restore_exception_handler();
    }

    public function testDuplicateException(): void
    {
        $exception = new \Exception();
        $operation = new Get(name: '_api_errors_problem', priority: 0, status: 400);
        $resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);
        $resourceMetadataCollectionFactory->expects($this->once())->method('create')
                                                                  ->with(Error::class)
                                                                  ->willReturn(
                                                                      new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])
                                                                  );

        $resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);
        $resourceClassResolver->expects($this->once())->method('isResourceClass')->with($exception::class)->willReturn(false);
        $kernel = $this->createStub(KernelInterface::class);
        $kernel->method('handle')->willReturnCallback(function ($request) {
            $this->assertTrue($request->attributes->has('_api_original_route'));
            $this->assertTrue($request->attributes->has('_api_original_route_params'));
            $this->assertTrue($request->attributes->has('_api_requested_operation'));
            $this->assertTrue($request->attributes->has('_api_previous_operation'));
            $this->assertEquals('_api_errors_problem', $request->attributes->get('_api_operation_name'));

            return new Response();
        });

        $request = Request::create('/');
        $request->attributes->set('_api_operation', new Get());
        $exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);
        $errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonproblem' => ['application/problem+json']], [], null, $resourceClassResolver);
        $errorListener->onKernelException($exceptionEvent);
    }

    public function testDuplicateExceptionWithHydra(): void
    {
        $exception = new \Exception();
        $operation = new Get(name: '_api_errors_hydra', priority: 0, status: 400);
        $resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);
        $resourceMetadataCollectionFactory->expects($this->once())->method('create')
                                                                  ->with(Error::class)
                                                                  ->willReturn(
                                                                      new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])
                                                                  );
        $resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);
        $resourceClassResolver->expects($this->once())->method('isResourceClass')->with($exception::class)->willReturn(false);

        $kernel = $this->createStub(KernelInterface::class);
        $kernel->method('handle')->willReturnCallback(function ($request) {
            $this->assertTrue($request->attributes->has('_api_original_route'));
            $this->assertTrue($request->attributes->has('_api_original_route_params'));
            $this->assertTrue($request->attributes->has('_api_requested_operation'));
            $this->assertTrue($request->attributes->has('_api_previous_operation'));
            $this->assertEquals('_api_errors_hydra', $request->attributes->get('_api_operation_name'));

            return new Response();
        });
        $request = Request::create('/');
        $request->attributes->set('_api_operation', new Get());
        $exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);
        $errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonld' => ['application/ld+json']], [], null, $resourceClassResolver);
        $errorListener->onKernelException($exceptionEvent);
    }

    public function testDuplicateExceptionWithErrorResource(): void
    {
        $exception = Error::createFromException(new \Exception(), 400);
        $operation = new Get(name: '_api_errors_hydra', priority: 0, status: 400, outputFormats: ['jsonld' => ['application/ld+json']]);
        $resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);
        $resourceMetadataCollectionFactory->expects($this->once())->method('create')
                                                                  ->with(Error::class)
                                                                  ->willReturn(
                                                                      new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])
                                                                  );

        $resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);
        $resourceClassResolver->expects($this->once())->method('isResourceClass')->with(Error::class)->willReturn(true);

        $kernel = $this->createStub(KernelInterface::class);
        $kernel->method('handle')->willReturnCallback(function ($request) {
            $this->assertTrue($request->attributes->has('_api_original_route'));
            $this->assertTrue($request->attributes->has('_api_original_route_params'));
            $this->assertTrue($request->attributes->has('_api_requested_operation'));
            $this->assertTrue($request->attributes->has('_api_previous_operation'));
            $this->assertEquals('_api_errors_hydra', $request->attributes->get('_api_operation_name'));

            $operation = $request->attributes->get('_api_operation');
            $this->assertEquals($operation->getNormalizationContext(), [
                // this flag is for bc layer on error normalizers
                'api_error_resource' => true,
                'ignored_attributes' => [
                    'trace',
                    'file',
                    'line',
                    'code',
                    'message',
                    'traceAsString',
                ],
            ]);

            return new Response();
        });
        $request = Request::create('/');
        $request->attributes->set('_api_operation', new Get());
        $exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);
        $identifiersExtractor = $this->createStub(IdentifiersExtractorInterface::class);
        $identifiersExtractor->method('getIdentifiersFromItem')->willReturn(['id' => 1]);
        $errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonld' => ['application/ld+json']], [], $identifiersExtractor, $resourceClassResolver);
        $errorListener->onKernelException($exceptionEvent);
    }
}

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\Symfony\Tests\EventListener;
15
16	use ApiPlatform\Metadata\ApiResource;
17	use ApiPlatform\Metadata\Get;
18	use ApiPlatform\Metadata\IdentifiersExtractorInterface;
19	use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
20	use ApiPlatform\Metadata\Resource\ResourceMetadataCollection;
21	use ApiPlatform\Metadata\ResourceClassResolverInterface;
22	use ApiPlatform\State\ApiResource\Error;
23	use ApiPlatform\Symfony\EventListener\ErrorListener;
24	use PHPUnit\Framework\TestCase;
25	use Symfony\Component\HttpFoundation\Request;
26	use Symfony\Component\HttpFoundation\Response;
27	use Symfony\Component\HttpKernel\Event\ExceptionEvent;
28	use Symfony\Component\HttpKernel\HttpKernelInterface;
29	use Symfony\Component\HttpKernel\KernelInterface;
30
31	class ErrorListenerTest extends TestCase
32	{
33	protected function tearDown(): void
34	{
NEW 35	restore_exception_handler();	×
36	}
37
38	public function testDuplicateException(): void
39	{
40	$exception = new \Exception();	×
41	$operation = new Get(name: '_api_errors_problem', priority: 0, status: 400);	×
42	$resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);	×
43	$resourceMetadataCollectionFactory->expects($this->once())->method('create')	×
44	->with(Error::class)	×
45	->willReturn(	×
46	new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])	×
47	);	×
48
49	$resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);	×
50	$resourceClassResolver->expects($this->once())->method('isResourceClass')->with($exception::class)->willReturn(false);	×
51	$kernel = $this->createStub(KernelInterface::class);	×
52	$kernel->method('handle')->willReturnCallback(function ($request) {	×
53	$this->assertTrue($request->attributes->has('_api_original_route'));	×
54	$this->assertTrue($request->attributes->has('_api_original_route_params'));	×
55	$this->assertTrue($request->attributes->has('_api_requested_operation'));	×
56	$this->assertTrue($request->attributes->has('_api_previous_operation'));	×
57	$this->assertEquals('_api_errors_problem', $request->attributes->get('_api_operation_name'));	×
58
59	return new Response();	×
60	});	×
61
62	$request = Request::create('/');	×
NEW 63	$request->attributes->set('_api_operation', new Get());	×
64	$exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);	×
NEW 65	$errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonproblem' => ['application/problem+json']], [], null, $resourceClassResolver);	×
66	$errorListener->onKernelException($exceptionEvent);	×
67	}
68
69	public function testDuplicateExceptionWithHydra(): void
70	{
71	$exception = new \Exception();	×
72	$operation = new Get(name: '_api_errors_hydra', priority: 0, status: 400);	×
73	$resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);	×
74	$resourceMetadataCollectionFactory->expects($this->once())->method('create')	×
75	->with(Error::class)	×
76	->willReturn(	×
77	new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])	×
78	);	×
79	$resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);	×
80	$resourceClassResolver->expects($this->once())->method('isResourceClass')->with($exception::class)->willReturn(false);	×
81
82	$kernel = $this->createStub(KernelInterface::class);	×
83	$kernel->method('handle')->willReturnCallback(function ($request) {	×
84	$this->assertTrue($request->attributes->has('_api_original_route'));	×
85	$this->assertTrue($request->attributes->has('_api_original_route_params'));	×
86	$this->assertTrue($request->attributes->has('_api_requested_operation'));	×
87	$this->assertTrue($request->attributes->has('_api_previous_operation'));	×
88	$this->assertEquals('_api_errors_hydra', $request->attributes->get('_api_operation_name'));	×
89
90	return new Response();	×
91	});	×
92	$request = Request::create('/');	×
NEW 93	$request->attributes->set('_api_operation', new Get());	×
94	$exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);	×
95	$errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonld' => ['application/ld+json']], [], null, $resourceClassResolver);	×
96	$errorListener->onKernelException($exceptionEvent);	×
97	}
98
99	public function testDuplicateExceptionWithErrorResource(): void
100	{
101	$exception = Error::createFromException(new \Exception(), 400);	×
102	$operation = new Get(name: '_api_errors_hydra', priority: 0, status: 400, outputFormats: ['jsonld' => ['application/ld+json']]);	×
103	$resourceMetadataCollectionFactory = $this->createMock(ResourceMetadataCollectionFactoryInterface::class);	×
104	$resourceMetadataCollectionFactory->expects($this->once())->method('create')	×
105	->with(Error::class)	×
106	->willReturn(	×
107	new ResourceMetadataCollection(Error::class, [new ApiResource(operations: [$operation])])	×
108	);	×
109
110	$resourceClassResolver = $this->createMock(ResourceClassResolverInterface::class);	×
111	$resourceClassResolver->expects($this->once())->method('isResourceClass')->with(Error::class)->willReturn(true);	×
112
113	$kernel = $this->createStub(KernelInterface::class);	×
114	$kernel->method('handle')->willReturnCallback(function ($request) {	×
115	$this->assertTrue($request->attributes->has('_api_original_route'));	×
116	$this->assertTrue($request->attributes->has('_api_original_route_params'));	×
117	$this->assertTrue($request->attributes->has('_api_requested_operation'));	×
118	$this->assertTrue($request->attributes->has('_api_previous_operation'));	×
119	$this->assertEquals('_api_errors_hydra', $request->attributes->get('_api_operation_name'));	×
120
121	$operation = $request->attributes->get('_api_operation');	×
122	$this->assertEquals($operation->getNormalizationContext(), [	×
123	// this flag is for bc layer on error normalizers
124	'api_error_resource' => true,	×
125	'ignored_attributes' => [	×
126	'trace',	×
127	'file',	×
128	'line',	×
129	'code',	×
130	'message',	×
131	'traceAsString',	×
132	],	×
133	]);	×
134
135	return new Response();	×
136	});	×
137	$request = Request::create('/');	×
NEW 138	$request->attributes->set('_api_operation', new Get());	×
139	$exceptionEvent = new ExceptionEvent($kernel, $request, HttpKernelInterface::SUB_REQUEST, $exception);	×
140	$identifiersExtractor = $this->createStub(IdentifiersExtractorInterface::class);	×
141	$identifiersExtractor->method('getIdentifiersFromItem')->willReturn(['id' => 1]);	×
142	$errorListener = new ErrorListener('action', null, true, [], $resourceMetadataCollectionFactory, ['jsonld' => ['application/ld+json']], [], $identifiersExtractor, $resourceClassResolver);	×
143	$errorListener->onKernelException($exceptionEvent);	×
144	}
145	}

api-platform / core / 10014117656

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