#10: throw UnsupportedMediaTypeHttpException in case Content-Type header is missing or unsupported.

Author: Mokhtar Tlili

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.2.5
+- Fix [#10](https://github.com/sfmok/request-input-bundle/issues/10) issue - throw `UnsupportedMediaTypeHttpException` in case `Content-Type` header is missing or unsupported.
+
+## 1.2.4
+- Update workflow to support dependencies checking
+- Update readme file
+- Update .gitignore file
+- Fix dependencies issue
+
 ## 1.2.3
 - Register services in bundle extension file
 - Fix exceptions issues

README.md

@@ -6,7 +6,7 @@
 
 **RequestInputBundle** converts request data into DTO inputs objects with validation.
 
-- Request data supported: `json`, `xml` and `form` based on header content type.
+- Request data supported: `json`, `xml` and `form` based on `Content-Type` header.
 - Resolve inputs arguments for controllers actions.
 - Create DTO inputs outside controllers
 - Validate DTO inputs objects.
@@ -94,6 +94,11 @@ Whether the request data contains invalid syntax or invalid attributes types a c
 
 - Data Error
 
+```json
+{
+  "title": 12
+}
+```
 ```json
 {
   "title": "Deserialization Failed",
@@ -109,6 +114,11 @@ Whether the request data contains invalid syntax or invalid attributes types a c
 ```
 - Syntax error:
 ```json
+{
+  "title": 12,
+}
+```
+```json
 {
   "title": "Deserialization Failed",
   "detail": "Syntax error",
@@ -151,7 +161,7 @@ class PostManager
 
     public function getInput(Request $request): InputInterface
     {
-        return $this->inputFactory->createFromRequest($request, PostInput::class, 'json');
+        return $this->inputFactory->createFromRequest($request, PostInput::class);
     }
 }
 ```

src/ArgumentResolver/InputArgumentResolver.php

@@ -5,34 +5,24 @@
 namespace Sfmok\RequestInput\ArgumentResolver;
 
 use Sfmok\RequestInput\InputInterface;
-use Sfmok\RequestInput\Attribute\Input;
 use Symfony\Component\HttpFoundation\Request;
 use Sfmok\RequestInput\Factory\InputFactoryInterface;
 use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
 use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
 
 class InputArgumentResolver implements ArgumentValueResolverInterface
 {
-    public function __construct(private InputFactoryInterface $inputFactory, private array $inputFormats)
+    public function __construct(private InputFactoryInterface $inputFactory)
     {
     }
 
     public function supports(Request $request, ArgumentMetadata $argument): bool
     {
-        if (!is_subclass_of($argument->getType(), InputInterface::class)) {
-            return false;
-        }
-
-        /** @var Input|null $inputAttribute */
-        if ($inputAttribute = $request->attributes->get('_input')) {
-            $this->inputFormats = [$inputAttribute->getFormat()];
-        }
-
-        return \in_array($request->getContentType(), $this->inputFormats);
+        return is_subclass_of($argument->getType(), InputInterface::class);
     }
 
     public function resolve(Request $request, ArgumentMetadata $argument): iterable
     {
-        yield $this->inputFactory->createFromRequest($request, $argument->getType(), $request->getContentType());
+        yield $this->inputFactory->createFromRequest($request, $argument->getType());
     }
 }

src/Attribute/Input.php

@@ -21,7 +21,7 @@ public function __construct(
 
     public function getFormat(): string
     {
-        return $this->format;
+        return mb_strtolower($this->format);
     }
 
     public function getGroups(): array

src/DependencyInjection/RequestInputExtension.php

@@ -36,6 +36,7 @@ public function load(array $configs, ContainerBuilder $container): void
                 '$serializer' => new Reference(SerializerInterface::class),
                 '$validator' => new Reference(ValidatorInterface::class),
                 '$skipValidation' => $config['skip_validation'],
+                '$inputFormats' => $config['formats'],
             ])
             ->setPublic(false)
         ;
@@ -48,7 +49,6 @@ public function load(array $configs, ContainerBuilder $container): void
         $container->register(InputArgumentResolver::class)
             ->setArguments([
                 '$inputFactory' => new Reference(InputFactoryInterface::class),
-                '$inputFormats' => $config['formats'],
             ])
             ->addTag('controller.argument_value_resolver', ['priority' => 40])
             ->setPublic(false)

src/EventListener/ReadInputListener.php

@@ -23,7 +23,7 @@ public function onKernelController(ControllerEvent $event): void
             return;
         }
 
-        if (!\in_array($inputMetadata->getFormat(), Input::INPUT_SUPPORTED_FORMATS)) {
+        if (!\in_array($inputMetadata->getFormat(), Input::INPUT_SUPPORTED_FORMATS, true)) {
             throw new UnexpectedFormatException(sprintf(
                 'Only the formats [%s] are supported. Got %s.',
                 implode(', ', Input::INPUT_SUPPORTED_FORMATS),

src/Factory/InputFactory.php

@@ -6,12 +6,10 @@
 
 use Sfmok\RequestInput\Attribute\Input;
 use Sfmok\RequestInput\Exception\DeserializationException;
-use Sfmok\RequestInput\Exception\UnexpectedFormatException;
 use Sfmok\RequestInput\InputInterface;
 use Sfmok\RequestInput\Exception\ValidationException;
 use Symfony\Component\HttpFoundation\Request;
-use Symfony\Component\Serializer\Exception\NotEncodableValueException;
-use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
+use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
 use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 use Symfony\Component\Serializer\SerializerInterface;
 use Symfony\Component\Validator\Validator\ValidatorInterface;
@@ -24,28 +22,39 @@ final class InputFactory implements InputFactoryInterface
     public function __construct(
         private SerializerInterface $serializer,
         private ValidatorInterface $validator,
-        private bool $skipValidation
+        private bool $skipValidation,
+        private array $inputFormats
     ) {
     }
 
-    public function createFromRequest(Request $request, string $type, string $format): InputInterface
+    public function createFromRequest(Request $request, string $type): InputInterface
     {
-        if (!\in_array($format, Input::INPUT_SUPPORTED_FORMATS)) {
-            throw new UnexpectedFormatException(sprintf(
-                'Only the formats [%s] are supported. Got %s.',
-                implode(', ', Input::INPUT_SUPPORTED_FORMATS),
-                $format
-            ));
+        // @codeCoverageIgnoreStart
+        if (\func_num_args() > 2) {
+            @trigger_error("Third argument of 'InputFactory::createFromRequest' is not in use and is removed, however the argument in the callers code can be removed without side-effects.", \E_USER_DEPRECATED);
+        }
+        // @codeCoverageIgnoreEnd
+
+        $contentType = $request->headers->get('CONTENT_TYPE');
+        if (null === $contentType || '' === $contentType) {
+            throw new UnsupportedMediaTypeHttpException('The "Content-Type" header must exist and not empty.');
+        }
+
+        $inputMetadata = $request->attributes->get('_input');
+        $formats = (array) ($inputMetadata?->getFormat() ?? $this->inputFormats);
+        $supportedMimeTypes = $this->getSupportedMimeTypes($request, $formats);
+
+        if (!\in_array($contentType, $supportedMimeTypes, true)) {
+            throw new UnsupportedMediaTypeHttpException(sprintf('The content-type "%s" is not supported. Supported MIME types are "%s".', $contentType, implode('", "', $supportedMimeTypes)));
         }
 
         $data = $request->getContent();
+        $format = $request->getContentType();
         if (Input::INPUT_FORM_FORMAT === $format) {
             $data = json_encode($request->request->all());
             $format = Input::INPUT_JSON_FORMAT;
         }
 
-        $inputMetadata = $request->attributes->get('_input');
-
         try {
             $input = $this->serializer->deserialize($data, $type, $format, $inputMetadata?->getContext() ?? []);
         } catch (UnexpectedValueException $exception) {
@@ -63,4 +72,14 @@ public function createFromRequest(Request $request, string $type, string $format
 
         return $input;
     }
+
+    private function getSupportedMimeTypes(Request $request, array $formats): array
+    {
+        $mimeTypes = [];
+        foreach ($formats as $format) {
+            $mimeTypes = [...$mimeTypes, ...$request->getMimeTypes($format)];
+        }
+
+        return $mimeTypes;
+    }
 }

src/Factory/InputFactoryInterface.php

@@ -9,5 +9,5 @@
 
 interface InputFactoryInterface
 {
-    public function createFromRequest(Request $request, string $type, string $format): InputInterface;
+    public function createFromRequest(Request $request, string $type): InputInterface;
 }

tests/ArgumentResolver/InputArgumentResolverTest.php

@@ -8,7 +8,6 @@
 use Prophecy\PhpUnit\ProphecyTrait;
 use Prophecy\Prophecy\ObjectProphecy;
 use Sfmok\RequestInput\ArgumentResolver\InputArgumentResolver;
-use Sfmok\RequestInput\Attribute\Input;
 use Sfmok\RequestInput\Factory\InputFactoryInterface;
 use Sfmok\RequestInput\Tests\Fixtures\Input\DummyInput;
 use Symfony\Component\HttpFoundation\Request;
@@ -25,119 +24,41 @@ protected function setUp(): void
         $this->inputFactory = $this->prophesize(InputFactoryInterface::class);
     }
 
-    public function testSupportsWithArgumentTypeNotInput(): void
-    {
-        $request = new Request();
-        $request->headers->set('Content-Type', 'application/json');
-        $argument = new ArgumentMetadata('foo', \stdClass::class, false, false, null);
-
-        $resolver = $this->createArgumentResolver(Input::INPUT_SUPPORTED_FORMATS);
-        $this->assertFalse($resolver->supports($request, $argument));
-    }
-
-    /**
-     * @dataProvider provideSupportsWithDefaultGlobalFormats
-     */
-    public function testSupportsWithDefaultGlobalFormats(bool $expected, ?string $contentType): void
-    {
-        $request = new Request();
-        $request->headers->set('Content-Type', $contentType);
-        $argument = new ArgumentMetadata('foo', DummyInput::class, false, false, null);
-
-        $resolver = $this->createArgumentResolver(Input::INPUT_SUPPORTED_FORMATS);
-        $this->assertSame($expected, $resolver->supports($request, $argument));
-    }
-
-    /**
-     * @dataProvider provideSupportsWithCustomGlobalFormats
-     */
-    public function testSupportsWithCustomGlobalFormats(bool $expected, ?string $contentType): void
-    {
-        $request = new Request();
-        $request->headers->set('Content-Type', $contentType);
-
-        $argument = new ArgumentMetadata('foo', DummyInput::class, false, false, null);
-
-        $resolver = $this->createArgumentResolver(['json']);
-        $this->assertSame($expected, $resolver->supports($request, $argument));
-    }
-
     /**
-     * @dataProvider provideSupportsWithCustomFormatsInInputAttribute
+     * @dataProvider provideSupportData
      */
-    public function testSupportsWithCustomFormatsInInputAttribute(bool $expected, ?string $contentType): void
+    public function testSupports(mixed $type, bool $expectedResult): void
     {
-        $request = new Request();
-        $request->headers->set('Content-Type', $contentType);
-        $request->attributes->set('_input', new Input('xml'));
-
-        $argument = new ArgumentMetadata('foo', DummyInput::class, false, false, null);
-
-        $resolver = $this->createArgumentResolver(Input::INPUT_SUPPORTED_FORMATS);
-        $this->assertSame($expected, $resolver->supports($request, $argument));
+        $argument = new ArgumentMetadata('foo', $type, false, false, null);
+        $this->assertSame($expectedResult, $this->createArgumentResolver()->supports(new Request(), $argument));
     }
 
-    public function testResolveSucceeds(): void
+    public function testResolve(): void
     {
         $dummyInput = new DummyInput();
-
         $request = new Request();
-        $request->headers->set('Content-Type', 'application/json');
-
-        $argument = new ArgumentMetadata('foo', DummyInput::class, false, false, null);
-
-        $resolver = $this->createArgumentResolver([Input::INPUT_SUPPORTED_FORMATS]);
+        $argument = new ArgumentMetadata('foo', $dummyInput::class, false, false, null);
 
         $this->inputFactory
-            ->createFromRequest($request, $argument->getType(), $request->getContentType())
+            ->createFromRequest($request, $dummyInput::class, $request->getContentType())
             ->shouldBeCalledOnce()
             ->willReturn($dummyInput)
         ;
 
+        $resolver = $this->createArgumentResolver();
         $this->assertEquals([$dummyInput], iterator_to_array($resolver->resolve($request, $argument)));
     }
 
-    public function provideSupportsWithDefaultGlobalFormats(): iterable
-    {
-        yield [false, null];
-        yield [false, 'application/rdf+xml'];
-        yield [false, 'text/html'];
-        yield [false, 'application/javascript'];
-        yield [false, 'text/plain'];
-        yield [false, 'application/ld+json'];
-        yield [true, 'application/json'];
-        yield [true, 'application/xml'];
-        yield [true, 'multipart/form-data'];
-    }
-
-    public function provideSupportsWithCustomGlobalFormats(): iterable
-    {
-        yield [false, null];
-        yield [false, 'application/rdf+xml'];
-        yield [false, 'text/html'];
-        yield [false, 'application/javascript'];
-        yield [false, 'text/plain'];
-        yield [false, 'application/ld+json'];
-        yield [true, 'application/json'];
-        yield [false, 'application/xml'];
-        yield [false, 'multipart/form-data'];
-    }
-
-    public function provideSupportsWithCustomFormatsInInputAttribute(): iterable
+    public function provideSupportData(): iterable
     {
-        yield [false, null];
-        yield [false, 'application/rdf+xml'];
-        yield [false, 'text/html'];
-        yield [false, 'application/javascript'];
-        yield [false, 'text/plain'];
-        yield [false, 'application/ld+json'];
-        yield [false, 'application/json'];
-        yield [true, 'application/xml'];
-        yield [false, 'multipart/form-data'];
+        yield [null, false];
+        yield [\stdClass::class, false];
+        yield ["Foo", false];
+        yield [DummyInput::class, true];
     }
 
-    private function createArgumentResolver(array $formats): InputArgumentResolver
+    private function createArgumentResolver(): InputArgumentResolver
     {
-        return new InputArgumentResolver($this->inputFactory->reveal(), $formats);
+        return new InputArgumentResolver($this->inputFactory->reveal());
     }
 }

tests/DependencyInjection/RequestInputExtensionTest.php

@@ -57,6 +57,23 @@ public function testLoadConfiguration(): void
         $this->assertServiceHasTags(ReadInputListener::class, ['kernel.event_listener']);
     }
 
+    public function testLoadConfigurationWithDisabledOption(): void
+    {
+        (new RequestInputExtension())->load(['request_input' => ['enabled' => false]], $this->container);
+
+        $services = [
+            InputArgumentResolver::class,
+            ExceptionListener::class,
+            ReadInputListener::class,
+            InputFactory::class,
+            InputMetadataFactory::class
+        ];
+
+        foreach ($services as $service) {
+            $this->assertFalse($this->container->hasDefinition($service), sprintf('Definition "%s" is found.', $service));
+        }
+    }
+
     private function assertContainerHas(array $services, array $aliases = []): void
     {
         foreach ($services as $service) {