overblog / GraphQLBundle

tests/Functional/Security/AccessTest.php

Braces -340 removed lines

@@ -26,343 +26,3 @@
     private string $userIsEnabledQuery = 'query ($hasAccess: Boolean = true) { user { isEnabled(hasAccess: $hasAccess) } }';
 
     private string $userFriendsQuery = <<<'QUERY'
-        query {
-          user {
-            friends(first: 2) {
-              edges {
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        QUERY;
-
-    private string $simpleMutationWithThunkQuery = <<<'MUTATION'
-        mutation M {
-          simpleMutationWithThunkFields(input: {inputData: %d, clientMutationId: "bac"}) {
-            result
-            clientMutationId
-          }
-        }
-        MUTATION;
-
-    public function setUp(): void
-    {
-        parent::setUp();
-        // load types
-        $this->loader = function ($class): void {
-            if (preg_match('@^'.preg_quote('Overblog\GraphQLBundle\Access\__DEFINITIONS__\\').'(.*)$@', $class, $matches)) {
-                $file = sys_get_temp_dir().'/OverblogGraphQLBundle/'.Kernel::VERSION.'/access/cache/testaccess/overblog/graphql-bundle/__definitions__/'.$matches[1].'.php';
-                if (file_exists($file)) {
-                    require $file;
-                }
-            }
-        };
-        spl_autoload_register($this->loader);
-    }
-
-    public function testCustomClassLoaderNotRegister(): void
-    {
-        $this->expectException(Error::class);
-        if ((int) phpversion() <= 7) {
-            $this->expectExceptionMessage('Class \'Overblog\GraphQLBundle\Access\__DEFINITIONS__\RootQueryType\' not found');
-        } else {
-            $this->expectExceptionMessage('Class "Overblog\GraphQLBundle\Access\__DEFINITIONS__\RootQueryType" not found');
-        }
-        spl_autoload_unregister($this->loader);
-        $this->assertResponse($this->userNameQuery, [], static::ANONYMOUS_USER, 'access');
-    }
-
-    public function testNotAuthenticatedUserAccessAsPromisedFulfilledTrue(): void
-    {
-        $this->assertResponse(
-            $this->userIsEnabledQuery,
-            ['data' => ['user' => ['isEnabled' => true]]],
-            static::ANONYMOUS_USER,
-            'access'
-        );
-    }
-
-    public function testNotAuthenticatedUserAccessAsPromisedFulfilledFalse(): void
-    {
-        $this->assertResponse(
-            $this->userIsEnabledQuery,
-            [
-                'data' => [
-                    'user' => [
-                        'isEnabled' => null,
-                    ],
-                ],
-                'extensions' => [
-                    'warnings' => [
-                        [
-                            'message' => 'Access denied to this field.',
-                            'locations' => [['line' => 1, 'column' => 45]],
-                            'path' => ['user', 'isEnabled'],
-                        ],
-                    ],
-                ],
-            ],
-            static::ANONYMOUS_USER,
-            'access',
-            '',
-            ['hasAccess' => false]
-        );
-    }
-
-    public function testNotAuthenticatedUserAccessToUserName(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'name' => null,
-                ],
-            ],
-            'extensions' => [
-                'warnings' => [
-                    [
-                        'message' => 'Access denied to this field.',
-                        'locations' => [['line' => 1, 'column' => 16]],
-                        'path' => ['user', 'name'],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userNameQuery, $expected, static::ANONYMOUS_USER, 'access');
-    }
-
-    public function testNonAuthenticatedUserAccessSecuredFieldWhichInitiallyResolvesToArray(): void
-    {
-        $expected = [
-            'data' => [
-                'youShallNotSeeThisUnauthenticated' => null,
-            ],
-            'extensions' => [
-                'warnings' => [
-                    [
-                        'message' => 'Access denied to this field.',
-                        'locations' => [
-                            [
-                                'line' => 2,
-                                'column' => 3,
-                            ],
-                        ],
-                        'path' => ['youShallNotSeeThisUnauthenticated'],
-                    ],
-                ],
-            ],
-        ];
-
-        $query = <<<'QUERY'
-            {
-              youShallNotSeeThisUnauthenticated {
-                secretValue
-                youAreAuthenticated
-              }
-            }
-            QUERY;
-
-        $this->assertResponse($query, $expected, static::ANONYMOUS_USER, 'access');
-    }
-
-    public function testFullyAuthenticatedUserAccessToUserName(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'name' => 'Dan',
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userNameQuery, $expected, static::USER_RYAN, 'access');
-    }
-
-    public function testNotAuthenticatedUserAccessToUserRoles(): void
-    {
-        $this->assertResponse($this->userRolesQuery, $this->expectedFailedUserRoles(), static::ANONYMOUS_USER, 'access');
-    }
-
-    public function testAuthenticatedUserAccessToUserRolesWithoutEnoughRights(): void
-    {
-        $this->assertResponse($this->userRolesQuery, $this->expectedFailedUserRoles(), static::USER_RYAN, 'access');
-    }
-
-    public function testUserWithCorrectRightsAccessToUserRoles(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'roles' => ['ROLE_USER'],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userRolesQuery, $expected, static::USER_ADMIN, 'access');
-    }
-
-    public function testUserForbiddenField(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => null,
-            ],
-            'extensions' => [
-                'warnings' => [
-                    [
-                        'message' => 'Access denied to this field.',
-                        'locations' => [
-                            [
-                                'line' => 3,
-                                'column' => 5,
-                            ],
-                        ],
-                        'path' => ['user', 'forbidden'],
-                    ],
-                ],
-            ],
-        ];
-
-        $query = <<<'QUERY'
-            query MyQuery {
-              user {
-                forbidden
-              }
-            }
-            QUERY;
-
-        $this->assertResponse($query, $expected, static::USER_ADMIN, 'access');
-    }
-
-    public function testUserAccessToUserFriends(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'friends' => [
-                        'edges' => [
-                            ['node' => ['name' => 'Nick']],
-                            ['node' => null],
-                        ],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsQuery, $expected, static::USER_ADMIN, 'access');
-    }
-
-    public function testUserAccessToUserFriendsAsArray(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'friendsAsArray' => [1, null, 3],
-                ],
-            ],
-        ];
-
-        $this->assertResponse('query { user { friendsAsArray } }', $expected, static::USER_ADMIN, 'access');
-    }
-
-    public function testMutationAllowedUser(): void
-    {
-        $result = 123;
-
-        $expected = [
-            'data' => [
-                'simpleMutationWithThunkFields' => [
-                    'result' => $result,
-                    'clientMutationId' => 'bac',
-                ],
-            ],
-        ];
-
-        $this->assertResponse(sprintf($this->simpleMutationWithThunkQuery, $result), $expected, static::USER_ADMIN, 'access');
-        $this->assertTrue(SimpleMutationWithThunkFieldsMutation::hasMutate(true));
-    }
-
-    public function testMutationAllowedButNoRightsToDisplayPayload(): void
-    {
-        $expected = [
-            'data' => [
-                'simpleMutationWithThunkFields' => [
-                    'result' => null,
-                    'clientMutationId' => 'bac',
-                ],
-            ],
-            'extensions' => [
-                'warnings' => [
-                    [
-                        'message' => 'Access denied to this field.',
-                        'locations' => [
-                            [
-                                'line' => 3,
-                                'column' => 5,
-                            ],
-                        ],
-                        'path' => ['simpleMutationWithThunkFields', 'result'],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse(sprintf($this->simpleMutationWithThunkQuery, 321), $expected, static::USER_ADMIN, 'access');
-        $this->assertTrue(SimpleMutationWithThunkFieldsMutation::hasMutate(true));
-    }
-
-    public function testMutationNotAllowedUser(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'Access denied to this field.',
-                    'locations' => [
-                        [
-                            'line' => 2,
-                            'column' => 3,
-                        ],
-                    ],
-                    'path' => ['simpleMutationWithThunkFields'],
-                ],
-            ],
-            'data' => [
-                'simpleMutationWithThunkFields' => null,
-            ],
-        ];
-
-        $this->assertResponse(sprintf($this->simpleMutationWithThunkQuery, 123), $expected, static::USER_RYAN, 'access');
-        $this->assertFalse(SimpleMutationWithThunkFieldsMutation::hasMutate(true));
-    }
-
-    private function expectedFailedUserRoles(): array
-    {
-        return [
-            'data' => [
-                'user' => [
-                    'roles' => null,
-                ],
-            ],
-            'extensions' => [
-                'warnings' => [
-                    [
-                        'message' => 'Access denied to this field.',
-                        'locations' => [
-                            [
-                                'line' => 1,
-                                'column' => 16,
-                            ],
-                        ],
-                        'path' => [
-                            'user',
-                            'roles',
-                        ],
-                    ],
-                ],
-            ],
-        ];
-    }
-}

tests/Functional/Exception/ExceptionTest.php

Braces -25 removed lines

@@ -18,28 +18,3 @@
     public function testExceptionIsMappedToAWarning(): void
     {
         $query = <<<'EOF'
-            query ExceptionQuery {
-                test
-            }
-            EOF;
-
-        $expectedData = [
-            'test' => null,
-        ];
-
-        $expectedErrors = [
-            [
-                'message' => 'Invalid argument exception',
-                'locations' => [
-                    [
-                        'line' => 2,
-                        'column' => 5,
-                    ],
-                ],
-                'path' => ['test'],
-            ],
-        ];
-
-        $this->assertGraphQL($query, $expectedData, $expectedErrors);
-    }
-}

tests/Functional/Controller/GraphControllerTest.php

Braces -318 removed lines

@@ -14,321 +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 = static::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 = static::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 = static::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('POST', '/', [], [], ['CONTENT_TYPE' => 'application/json']);
-    }
-
-    public function testEndpointWithJsonContentTypeAndGetQuery(): void
-    {
-        $client = static::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 = static::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/', [], [], ['CONTENT_TYPE' => 'application/json'], '{');
-        $client->getResponse()->getContent();
-    }
-
-    public function testEndpointActionWithVariables(): void
-    {
-        $client = static::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 = static::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 = static::createClient(['test_case' => 'connection']);
-        $this->disableCatchExceptions($client);
-
-        $query = <<<'EOF'
-            query {
-              user
-            }
-            EOF;
-
-        $client->request('GET', '/graphql/fake', ['query' => $query]);
-    }
-
-    public function testEndpointActionWithOperationName(): void
-    {
-        $client = static::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 = static::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 = static::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 = static::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 = static::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 = static::createClient();
-        $this->disableCatchExceptions($client);
-        $client->request('GET', '/batch', [], [], ['CONTENT_TYPE' => 'application/json'], '{"test" : {"query": 1}}');
-        $client->getResponse()->getContent();
-    }
-
-    public function testPreflightedRequestWhenDisabled(): void
-    {
-        $client = static::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 = static::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 = static::createClient(['test_case' => 'connectionWithCORS']);
-        $this->disableCatchExceptions($client);
-        $client->request('OPTIONS', '/batch', [], [], ['HTTP_Origin' => 'http://example.com']);
-        $this->assertCORSHeadersExists($client);
-    }
-
-    public function testNoCORSHeadersIfOriginHeaderNotExists(): void
-    {
-        $client = static::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);
-    }
-
-    /**
-     * @param KernelBrowser $client
-     */
-    private function assertCORSHeadersNotExists($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);
-    }
-
-    /**
-     * @param KernelBrowser $client
-     */
-    private function assertCORSHeadersExists($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'));
-    }
-}

tests/Functional/Security/QueryComplexityTest.php

Braces -70 removed lines

@@ -9,73 +9,3 @@
 final class QueryComplexityTest extends TestCase
 {
     private string $userFriendsWithoutLimitQuery = <<<'EOF'
-        query {
-          user {
-            friends {
-              edges {
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        EOF;
-
-    private string $userFriendsWithLimitQuery = <<<'EOF'
-        query {
-          user {
-            friends(first: 1) {
-              edges {
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        EOF;
-
-    public function testComplexityReachLimitation(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'Max query complexity should be 10 but got 54.',
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithoutLimitQuery, $expected, self::ANONYMOUS_USER, 'queryComplexity');
-    }
-
-    public function testComplexityReachLimitationEnv(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'Max query complexity should be 10 but got 54.',
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithoutLimitQuery, $expected, self::ANONYMOUS_USER, 'queryComplexityEnv');
-    }
-
-    public function testComplexityUnderLimitation(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'friends' => [
-                        'edges' => [
-                            ['node' => ['name' => 'Nick']],
-                        ],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithLimitQuery, $expected, self::ANONYMOUS_USER, 'queryComplexity');
-    }
-}

tests/Functional/Security/QueryMaxDepthTest.php

Braces -77 removed lines

@@ -9,80 +9,3 @@
 final class QueryMaxDepthTest extends TestCase
 {
     private string $userFriendsWithoutViolationQuery = <<<'EOF'
-        query {
-          user {
-            friends(first:1) {
-              edges {
-                node {
-                  name
-                }
-              }
-            }
-          }
-        }
-        EOF;
-
-    private string $userFriendsWithViolationQuery = <<<'EOF'
-        query {
-          user {
-            friends(first: 1) {
-              edges {
-                node {
-                  name
-                  friends {
-                    edges {
-                      node {
-                        name
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        EOF;
-
-    public function testMaxDepthReachLimitation(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'Max query depth should be 3 but got 6.',
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithViolationQuery, $expected, self::ANONYMOUS_USER, 'queryMaxDepth');
-    }
-
-    public function testMaxDepthReachLimitationEnv(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'Max query depth should be 3 but got 6.',
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithViolationQuery, $expected, self::ANONYMOUS_USER, 'queryMaxDepthEnv');
-    }
-
-    public function testComplexityUnderLimitation(): void
-    {
-        $expected = [
-            'data' => [
-                'user' => [
-                    'friends' => [
-                        'edges' => [
-                            ['node' => ['name' => 'Nick']],
-                        ],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->userFriendsWithoutViolationQuery, $expected, self::ANONYMOUS_USER, 'queryMaxDepth');
-    }
-}

tests/Functional/Security/DisableIntrospectionTest.php

Braces -29 removed lines

@@ -9,32 +9,3 @@
 final class DisableIntrospectionTest extends TestCase
 {
     private string $introspectionQuery = <<<'EOF'
-        query {
-          __schema {
-            types {
-              name
-              description
-            }
-          }
-        }
-        EOF;
-
-    public function testIntrospectionDisabled(): void
-    {
-        $expected = [
-            'errors' => [
-                [
-                    'message' => 'GraphQL introspection is not allowed, but the query contained __schema or __type',
-                    'locations' => [
-                        [
-                            'line' => 2,
-                            'column' => 3,
-                        ],
-                    ],
-                ],
-            ],
-        ];
-
-        $this->assertResponse($this->introspectionQuery, $expected, self::ANONYMOUS_USER, 'disableIntrospection');
-    }
-}