overblog / GraphQLBundle

tests/Definition/Type/CustomScalarTypeTest.php

Spacing +8 added lines, -8 removed lines

@@ -22,12 +22,12 @@ 
     public function testScalarTypeConfig(): void
     {
         $this->assertScalarTypeConfig(new YearScalarType());
-        $this->assertScalarTypeConfig(fn () => new YearScalarType());
+        $this->assertScalarTypeConfig(fn() => new YearScalarType());
     }
 
     public function testWithoutScalarTypeConfig(): void
     {
-        $genericFunc = fn ($value) => $value;
+        $genericFunc = fn($value) => $value;
         /** @phpstan-ignore-next-line */
         $type = new CustomScalarType([
             'serialize' => $genericFunc,
@@ -57,7 +57,7 @@ 
             ScalarType::class,
             $got
         ));
-        $type = new CustomScalarType(['name' => $name, 'scalarType' => $scalarType, 'serialize' => fn (mixed $input): mixed => '']);
+        $type = new CustomScalarType(['name' => $name, 'scalarType' => $scalarType, 'serialize' => fn(mixed $input): mixed => '']);
         $type->assertValid();
     }
 
@@ -66,11 +66,11 @@ 
         yield [false, 'false'];
         yield [new stdClass(), 'instance of stdClass'];
         yield [
-            fn () => false,
+            fn() => false,
             'false',
         ];
         yield [
-            fn () => new stdClass(),
+            fn() => new stdClass(),
             'instance of stdClass',
         ];
     }
@@ -84,9 +84,9 @@ 
     {
         $type = new CustomScalarType([
             'scalarType' => $scalarType,
-            'serialize' => fn () => 'serialize',
-            'parseValue' => fn () => 'parseValue',
-            'parseLiteral' => fn () => 'parseLiteral',
+            'serialize' => fn() => 'serialize',
+            'parseValue' => fn() => 'parseValue',
+            'parseLiteral' => fn() => 'parseLiteral',
         ]);
 
         $this->assertSame('50 AC', $type->serialize(50));

src/Definition/Type/CustomScalarType.php

Spacing +2 added lines, -2 removed lines

@@ -77,7 +77,7 @@ 
             return parent::$type($value);
         }
 
-        $scalarType = match (true) {
+        $scalarType = match(true) {
             $this->config['scalarType'] instanceof ScalarType => $this->config['scalarType'],
             is_callable($this->config['scalarType']) => $this->config['scalarType'](),
             default => $this->config['scalarType'],
@@ -94,7 +94,7 @@ 
             return;
         }
 
-        $scalarType = match (true) {
+        $scalarType = match(true) {
             $this->config['scalarType'] instanceof ScalarType => $this->config['scalarType'],
             is_callable($this->config['scalarType']) => $this->config['scalarType'](),
             default => $this->config['scalarType'],

tests/Functional/Generator/TypeGeneratorTest.php

Spacing -35 removed lines

@@ -111,38 +111,3 @@
 
         // this is the part is why we must make this test run in separate process
         $query = <<<'EOF'
-            mutation {
-              conflictingValidatorNamespaces(test: "123", test2: "1", test3: "4")
-            }
-            EOF;
-
-        $response = static::query(
-            $query,
-            self::USER_RYAN,
-            'conflictingValidatorNamespaces'
-        )->getResponse()->getContent();
-
-        $this->assertEquals('{"data":{"conflictingValidatorNamespaces":true}}', $response);
-        // end part
-
-        // Validate definition file
-        /** @var string $definitionFile */
-        $definitionFile = file_get_contents($kernel->getCacheDir().'/overblog/graphql-bundle/__definitions__/MutationType.php');
-
-        $this->assertStringContainsString(
-            'use Symfony\Component\Validator\Constraints as SymfonyConstraints;',
-            $definitionFile,
-            'Generated definition file should contain import of Symfony\Component\Validator\Constraints aliased as SymfonyConstraints'
-        );
-        $this->assertStringNotContainsString(
-            'use '.Validator\CustomValidator1\Constraint::class,
-            $definitionFile,
-            'Generated definition file should not contain imports of custom constraints, FQCN should be used instead'
-        );
-        $this->assertStringNotContainsString(
-            'use '.Validator\CustomValidator2\Constraint::class,
-            $definitionFile,
-            'Generated definition file should not contain imports of custom constraints, FQCN should be used instead'
-        );
-    }
-}

tests/Functional/MultipleSchema/MultipleSchemaTest.php

Spacing -64 removed lines

@@ -26,67 +26,3 @@
         $this->assertSame([['node' => ['username' => 'user1']]], $result['data']['users']['edges']);
 
         $query = <<<'EOF'
-            mutation M {
-              addUser(input: {username: "user1"}) {
-                user {
-                  username
-                }
-              }
-            }
-            EOF;
-
-        $expectedData = [
-            'addUser' => [
-                'user' => ['username' => 'user1'],
-            ],
-        ];
-
-        $this->assertGraphQL($query, $expectedData, null, [], 'public');
-    }
-
-    public function testInternalSchema(): void
-    {
-        $result = $this->executeGraphQLRequest('{bar foo}', [], 'internal');
-        $this->assertSame('bar', $result['data']['bar']);
-        $this->assertSame('foo', $result['data']['foo']);
-        $this->assertSchemaQueryTypeName('InternalQuery');
-
-        $result = $this->executeGraphQLRequest('{users{edges{node{username email}}}}', [], 'internal');
-        $this->assertSame([['node' => ['username' => 'user1', 'email' => 'topsecret']]], $result['data']['users']['edges']);
-
-        $query = <<<'EOF'
-            mutation M {
-              addUser(input: {username: "user1"}) {
-                user {
-                  username
-                  email
-                }
-              }
-            }
-            EOF;
-
-        $expectedData = [
-            'addUser' => [
-                'user' => ['username' => 'user1', 'email' => 'email1'],
-            ],
-        ];
-
-        $this->assertGraphQL($query, $expectedData, null, [], 'internal');
-    }
-
-    public function testUnknownTypeShouldThrowAnUnresolvableException(): void
-    {
-        // @phpstan-ignore-next-line
-        $schema = $this->getContainer()->get('overblog_graphql.request_executor')->getSchema('public');
-        $this->expectException(UnresolvableException::class);
-        $this->expectExceptionMessage('Could not find type with alias "unknown". Did you forget to define it?');
-        $schema->getType('unknown');
-    }
-
-    private function assertSchemaQueryTypeName(string $typeName): void
-    {
-        // @phpstan-ignore-next-line
-        $query = $this->getContainer()->get('overblog_graphql.type_resolver')->resolve($typeName);
-        $this->assertSame('Query', $query->name);
-    }
-}

tests/ExpressionLanguage/TestCase.php

Spacing +4 added lines, -4 removed lines

@@ -106,13 +106,13 @@
     protected function createGraphQLServices(array $services = []): GraphQLServices
     {
         $locateableServices = [
-            TypeResolver::class => fn () => $this->createMock(TypeResolver::class),
-            QueryResolver::class => fn () => $this->createMock(QueryResolver::class),
-            MutationResolver::class => fn () => $$this->createMock(MutationResolver::class),
+            TypeResolver::class => fn() => $this->createMock(TypeResolver::class),
+            QueryResolver::class => fn() => $this->createMock(QueryResolver::class),
+            MutationResolver::class => fn() => $$this->createMock(MutationResolver::class),
         ];
 
         foreach ($services as $id => $service) {
-            $locateableServices[$id] = fn () => $service;
+            $locateableServices[$id] = fn() => $service;
         }
 
         return new GraphQLServices($locateableServices);

tests/EventListener/TypeDecoratorListenerTest.php

Spacing +14 added lines, -14 removed lines

@@ -32,10 +32,10 @@ 
      *
      * @dataProvider specialTypeFieldProvider
      */
-    public function testSpecialField($fieldName, ObjectType|UnionType|InterfaceType|CustomScalarType $typeWithSpecialField, callable $fieldValueRetriever = null, $strict = true): void
+    public function testSpecialField($fieldName, ObjectType | UnionType | InterfaceType | CustomScalarType $typeWithSpecialField, callable $fieldValueRetriever = null, $strict = true): void
     {
         if (null === $fieldValueRetriever) {
-            $fieldValueRetriever = fn (ObjectType|UnionType|InterfaceType|CustomScalarType $type, $fieldName) => $type->config[$fieldName];
+            $fieldValueRetriever = fn(ObjectType | UnionType | InterfaceType | CustomScalarType $type, $fieldName) => $type->config[$fieldName];
         }
         $expected = static function (): void {
         };
@@ -66,8 +66,8 @@ 
                 yield 'toto' => ['type' => Type::boolean(), 'resolve' => null];
             },
         ]);
-        $barResolver = static fn () => 'bar';
-        $bazResolver = static fn () => 'baz';
+        $barResolver = static fn() => 'bar';
+        $bazResolver = static fn() => 'baz';
 
         $this->decorate(
             [$objectType->name => $objectType],
@@ -102,7 +102,7 @@ 
             [$objectType->name => $objectType],
             [
                 $objectType->name => [
-                    'bar' => fn ($value, $args) => $args,
+                    'bar' => fn($value, $args) => $args,
                 ],
             ]
         );
@@ -220,7 +220,7 @@ 
 
     public function testCustomScalarTypeUnknownField(): void
     {
-        $customScalarType = new CustomScalarType(['name' => 'Foo', 'scalarType' => Type::string(), 'serialize' => fn (mixed $input): mixed => '']);
+        $customScalarType = new CustomScalarType(['name' => 'Foo', 'scalarType' => Type::string(), 'serialize' => fn(mixed $input): mixed => '']);
         $this->assertDecorateException(
             [$customScalarType->name => $customScalarType],
             [
@@ -272,7 +272,7 @@ 
 
     public function specialTypeFieldProvider(): array
     {
-        $objectWithResolveField = new ObjectType(['name' => 'Bar', 'fields' => [], 'resolveField' => fn () => '']);
+        $objectWithResolveField = new ObjectType(['name' => 'Bar', 'fields' => [], 'resolveField' => fn() => '']);
 
         return [
             // isTypeOf
@@ -281,18 +281,18 @@ 
             [
                 ResolverMapInterface::RESOLVE_FIELD,
                 $objectWithResolveField,
-                fn (ObjectType $type) => $type->resolveFieldFn,
+                fn(ObjectType $type) => $type->resolveFieldFn,
                 false,
             ],
             [ResolverMapInterface::RESOLVE_FIELD, $objectWithResolveField, null, false],
             // resolveType
-            [ResolverMapInterface::RESOLVE_TYPE, new UnionType(['name' => 'Baz', 'resolveType' => fn () => '', 'types' => []])],
-            [ResolverMapInterface::RESOLVE_TYPE, new InterfaceType(['name' => 'Baz', 'fields' => [], 'resolveType' => fn (mixed $objectValue, mixed $context, ResolveInfo $resolveInfo): string => ''])],
+            [ResolverMapInterface::RESOLVE_TYPE, new UnionType(['name' => 'Baz', 'resolveType' => fn() => '', 'types' => []])],
+            [ResolverMapInterface::RESOLVE_TYPE, new InterfaceType(['name' => 'Baz', 'fields' => [], 'resolveType' => fn(mixed $objectValue, mixed $context, ResolveInfo $resolveInfo): string => ''])],
             // custom scalar
-            [ResolverMapInterface::SERIALIZE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn (mixed $input): mixed => ''])],
-            [ResolverMapInterface::PARSE_VALUE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn (mixed $input): mixed => '', 'parseValue' => fn (mixed $input): mixed => ''])],
-            [ResolverMapInterface::PARSE_LITERAL, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn (mixed $input): mixed => '', 'parseLiteral' => fn (Node $a, array|null $b): mixed => ''])],
-            [ResolverMapInterface::SCALAR_TYPE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn (mixed $input): mixed => ''])],
+            [ResolverMapInterface::SERIALIZE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn(mixed $input): mixed => ''])],
+            [ResolverMapInterface::PARSE_VALUE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn(mixed $input): mixed => '', 'parseValue' => fn(mixed $input): mixed => ''])],
+            [ResolverMapInterface::PARSE_LITERAL, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn(mixed $input): mixed => '', 'parseLiteral' => fn(Node $a, array | null $b): mixed => ''])],
+            [ResolverMapInterface::SCALAR_TYPE, new CustomScalarType(['name' => 'Custom', 'scalarType' => Type::string(), 'serialize' => fn(mixed $input): mixed => ''])],
         ];
     }
 

src/Config/TypeDefinition.php

Spacing +10 added lines, -11 removed lines

@@ -42,7 +42,7 @@ 
         $node
             ->isRequired()
             ->validate()
-                ->ifTrue(fn ($name) => !preg_match('/^[_a-z][_0-9a-z]*$/i', $name))
+                ->ifTrue(fn($name) => !preg_match('/^[_a-z][_0-9a-z]*$/i', $name))
                 ->thenInvalid('Invalid type name "%s". (see http://spec.graphql.org/June2018/#sec-Names)')
             ->end()
         ;
@@ -157,7 +157,7 @@ 
     {
         $node
             ->beforeNormalization()
-                ->ifTrue(fn ($options) => !empty($options[$old]) && empty($options[$new]))
+                ->ifTrue(fn($options) => !empty($options[$old]) && empty($options[$new]))
                 ->then(function ($options) use ($old, $new) {
                     if (is_callable($options[$old])) {
                         if (is_array($options[$old])) {
@@ -167,8 +167,7 @@ 
                         }
                     } elseif (is_string($options[$old])) {
                         $options[$new]['expression'] = ExpressionLanguage::stringHasTrigger($options[$old]) ?
-                            ExpressionLanguage::unprefixExpression($options[$old]) :
-                            json_encode($options[$old]);
+                            ExpressionLanguage::unprefixExpression($options[$old]) : json_encode($options[$old]);
                     } else {
                         $options[$new]['expression'] = json_encode($options[$old]);
                     }
@@ -177,7 +176,7 @@ 
                 })
             ->end()
             ->beforeNormalization()
-                ->ifTrue(fn ($options) => is_array($options) && array_key_exists($old, $options))
+                ->ifTrue(fn($options) => is_array($options) && array_key_exists($old, $options))
                 ->then(function ($options) use ($old) {
                     unset($options[$old]);
 
@@ -185,7 +184,7 @@ 
                 })
             ->end()
             ->validate()
-                ->ifTrue(fn (array $v) => !empty($v[$new]) && !empty($v[$old]))
+                ->ifTrue(fn(array $v) => !empty($v[$new]) && !empty($v[$old]))
                 ->thenInvalid(sprintf(
                     '"%s" and "%s" should not be used together in "%%s".',
                     $new,
@@ -203,17 +202,17 @@ 
         $node
             ->info($info)
             ->validate()
-                ->ifTrue(fn (array $v) => !empty($v['function']) && !empty($v['expression']))
+                ->ifTrue(fn(array $v) => !empty($v['function']) && !empty($v['expression']))
                 ->thenInvalid('"function" and "expression" should not be use together.')
             ->end()
             ->beforeNormalization()
                 // Allow short syntax
-                ->ifTrue(fn ($options) => is_string($options) && ExpressionLanguage::stringHasTrigger($options))
-                ->then(fn ($options) => ['expression' => ExpressionLanguage::unprefixExpression($options)])
+                ->ifTrue(fn($options) => is_string($options) && ExpressionLanguage::stringHasTrigger($options))
+                ->then(fn($options) => ['expression' => ExpressionLanguage::unprefixExpression($options)])
             ->end()
             ->beforeNormalization()
-                ->ifTrue(fn ($options) => is_string($options) && !ExpressionLanguage::stringHasTrigger($options))
-                ->then(fn ($options) => ['function' => $options])
+                ->ifTrue(fn($options) => is_string($options) && !ExpressionLanguage::stringHasTrigger($options))
+                ->then(fn($options) => ['function' => $options])
             ->end()
             ->children()
                 ->scalarNode('function')->end()

src/DependencyInjection/Compiler/IdentifyCallbackServiceIdsPass.php

Spacing +1 added lines, -1 removed lines

@@ -64,7 +64,7 @@
                 $alias = $container->getAlias($id);
                 $id = (string) $alias;
                 $definition = $container->getDefinition($id);
-            } catch (ServiceNotFoundException|InvalidArgumentException $e) {
+            } catch (ServiceNotFoundException | InvalidArgumentException $e) {
                 return;
             }
         }

tests/Functional/Controller/GraphControllerTest.php

Spacing -312 removed lines

@@ -14,315 +14,3 @@
 final class GraphControllerTest extends TestCase
 {
     private string $friendsQuery = <<<'EOF'
-        query FriendsQuery {
-          user {
-            friends(first: 2) {
-              totalCount
-              edges {
-                friendshipTime
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        EOF;
-
-    private string $friendsTotalCountQuery = <<<'EOF'
-        query FriendsTotalCountQuery {
-          user {
-            friends {
-              totalCount
-            }
-          }
-        }
-        EOF;
-
-    private array $expectedData = [
-        'user' => [
-            'friends' => [
-                'totalCount' => 4,
-                'edges' => [
-                    [
-                        'friendshipTime' => 'Yesterday',
-                        'node' => [
-                            'name' => 'Nick',
-                        ],
-                    ],
-                    [
-                        'friendshipTime' => 'Yesterday',
-                        'node' => [
-                            'name' => 'Lee',
-                        ],
-                    ],
-                ],
-            ],
-        ],
-    ];
-
-    /**
-     * @dataProvider graphQLEndpointUriProvider
-     */
-    public function testEndpointAction(string $uri): void
-    {
-        $client = self::createClient(['test_case' => 'connectionWithCORS']);
-        $this->disableCatchExceptions($client);
-
-        $client->request('GET', $uri, ['query' => $this->friendsQuery], [], ['CONTENT_TYPE' => 'application/graphql;charset=utf8', 'HTTP_Origin' => 'http://example.com']);
-        $result = $client->getResponse()->getContent();
-        $this->assertSame(['data' => $this->expectedData], json_decode($result, true), $result);
-        $this->assertCORSHeadersExists($client);
-    }
-
-    public function graphQLEndpointUriProvider(): array
-    {
-        return [
-            ['/'],
-            ['/graphql/default'],
-        ];
-    }
-
-    public function testEndpointWithEmptyQuery(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('Must provide query parameter');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/', []);
-        $client->getResponse()->getContent();
-    }
-
-    public function testEndpointWithEmptyPostJsonBodyQuery(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('The request content body must not be empty when using json content type request.');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('POST', '/', [], [], ['CONTENT_TYPE' => 'application/json']);
-    }
-
-    public function testEndpointWithJsonContentTypeAndGetQuery(): void
-    {
-        $client = self::createClient(['test_case' => 'connectionWithCORS']);
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/', ['query' => $this->friendsQuery], [], ['CONTENT_TYPE' => 'application/json']);
-        $result = $client->getResponse()->getContent();
-        $this->assertSame(['data' => $this->expectedData], json_decode($result, true), $result);
-    }
-
-    public function testEndpointWithInvalidBodyQuery(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('POST body sent invalid JSON');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/', [], [], ['CONTENT_TYPE' => 'application/json'], '{');
-        $client->getResponse()->getContent();
-    }
-
-    public function testEndpointActionWithVariables(): void
-    {
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $query = <<<'EOF'
-            query FriendsQuery($firstFriends: Int) {
-              user {
-                friends(first: $firstFriends) {
-                  totalCount
-                  edges {
-                    friendshipTime
-                    node {
-                      name
-                    }
-                  }
-                }
-              }
-            }
-            EOF;
-
-        $content = json_encode(['query' => $query, 'variables' => '{"firstFriends": 2}']) ?: null;
-        $client->request('GET', '/', [], [], ['CONTENT_TYPE' => 'application/json'], $content);
-        $this->assertSame(200, $client->getResponse()->getStatusCode());
-    }
-
-    public function testEndpointActionWithInvalidVariables(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('Variables are invalid JSON');
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $query = <<<'EOF'
-            query {
-              user
-            }
-            EOF;
-
-        $client->request('GET', '/', ['query' => $query, 'variables' => '"firstFriends": 2}']);
-    }
-
-    public function testMultipleEndpointActionWithUnknownSchemaName(): void
-    {
-        $this->expectException(NotFoundHttpException::class);
-        $this->expectExceptionMessage('Could not find "fake" schema.');
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $query = <<<'EOF'
-            query {
-              user
-            }
-            EOF;
-
-        $client->request('GET', '/graphql/fake', ['query' => $query]);
-    }
-
-    public function testEndpointActionWithOperationName(): void
-    {
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $query = $this->friendsQuery."\n".$this->friendsTotalCountQuery;
-
-        $client->request('POST', '/', ['query' => $query, 'operationName' => 'FriendsQuery'], [], ['CONTENT_TYPE' => 'application/x-www-form-urlencoded']);
-        $result = $client->getResponse()->getContent();
-        $this->assertSame(['data' => $this->expectedData], json_decode($result, true), $result);
-    }
-
-    /**
-     * @dataProvider graphQLBatchEndpointUriProvider
-     */
-    public function testBatchEndpointAction(string $uri): void
-    {
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $data = [
-            [
-                'id' => 'friends',
-                'query' => $this->friendsQuery,
-            ],
-            [
-                'id' => 'friendsTotalCount',
-                'query' => $this->friendsTotalCountQuery,
-            ],
-        ];
-
-        $content = json_encode($data) ?: null;
-        $client->request('POST', $uri, [], [], ['CONTENT_TYPE' => 'application/json'], $content);
-        $result = $client->getResponse()->getContent();
-
-        $expected = [
-            ['id' => 'friends', 'payload' => ['data' => $this->expectedData]],
-            ['id' => 'friendsTotalCount', 'payload' => ['data' => ['user' => ['friends' => ['totalCount' => 4]]]]],
-        ];
-        $this->assertSame($expected, json_decode($result, true), $result);
-    }
-
-    public function graphQLBatchEndpointUriProvider(): array
-    {
-        return [
-            ['/batch'],
-            ['/graphql/default/batch'],
-        ];
-    }
-
-    public function testBatchEndpointWithEmptyQuery(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('Must provide at least one valid query.');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/batch', [], [], ['CONTENT_TYPE' => 'application/json'], '{}');
-        $client->getResponse()->getContent();
-    }
-
-    public function testBatchEndpointWrongContentType(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('Batching parser only accepts "application/json" or "multipart/form-data" content-type but got "".');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/batch');
-        $client->getResponse()->getContent();
-    }
-
-    public function testBatchEndpointWithInvalidJson(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('POST body sent invalid JSON');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/batch', [], [], ['CONTENT_TYPE' => 'application/json'], '{');
-        $client->getResponse()->getContent();
-    }
-
-    public function testBatchEndpointWithInvalidQuery(): void
-    {
-        $this->expectException(BadRequestHttpException::class);
-        $this->expectExceptionMessage('1 is not a valid query');
-        $client = self::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/batch', [], [], ['CONTENT_TYPE' => 'application/json'], '{"test" : {"query": 1}}');
-        $client->getResponse()->getContent();
-    }
-
-    public function testPreflightedRequestWhenDisabled(): void
-    {
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-        $client->request('OPTIONS', '/', [], [], ['HTTP_Origin' => 'http://example.com']);
-        $response = $client->getResponse();
-        $this->assertSame(200, $response->getStatusCode());
-        $this->assertCORSHeadersNotExists($client);
-    }
-
-    public function testUnAuthorizedMethod(): void
-    {
-        $client = self::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-        $client->request('PUT', '/', [], [], ['HTTP_Origin' => 'http://example.com']);
-        $this->assertSame(405, $client->getResponse()->getStatusCode());
-    }
-
-    public function testPreflightedRequestWhenEnabled(): void
-    {
-        $client = self::createClient(['test_case' => 'connectionWithCORS']);
-        $this->disableCatchExceptions($client);
-        $client->request('OPTIONS', '/batch', [], [], ['HTTP_Origin' => 'http://example.com']);
-        $this->assertCORSHeadersExists($client);
-    }
-
-    public function testNoCORSHeadersIfOriginHeaderNotExists(): void
-    {
-        $client = self::createClient(['test_case' => 'connectionWithCORS']);
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/', ['query' => $this->friendsQuery], [], ['CONTENT_TYPE' => 'application/graphql']);
-        $result = $client->getResponse()->getContent();
-        $this->assertSame(['data' => $this->expectedData], json_decode($result, true), $result);
-        $this->assertCORSHeadersNotExists($client);
-    }
-
-    private function assertCORSHeadersNotExists(KernelBrowser $client): void
-    {
-        $headers = $client->getResponse()->headers->all();
-        $this->assertArrayNotHasKey('access-control-allow-origin', $headers);
-        $this->assertArrayNotHasKey('access-control-allow-methods', $headers);
-        $this->assertArrayNotHasKey('access-control-allow-credentials', $headers);
-        $this->assertArrayNotHasKey('access-control-allow-headers', $headers);
-        $this->assertArrayNotHasKey('access-control-max-age', $headers);
-    }
-
-    private function assertCORSHeadersExists(KernelBrowser $client): void
-    {
-        $response = $client->getResponse();
-        $this->assertSame(200, $response->getStatusCode());
-        $this->assertSame('http://example.com', $response->headers->get('Access-Control-Allow-Origin'));
-        $this->assertSame('OPTIONS, GET, POST', $response->headers->get('Access-Control-Allow-Methods'));
-        $this->assertSame('true', $response->headers->get('Access-Control-Allow-Credentials'));
-        $this->assertSame('Content-Type, Authorization', $response->headers->get('Access-Control-Allow-Headers'));
-        $this->assertSame('3600', $response->headers->get('Access-Control-Max-Age'));
-    }
-}