import { formatISO } from 'date-fns/formatISO'; import { subHours } from 'date-fns/subHours'; import { buildASTSchema, parse, print } from 'graphql'; import { createLogger } from 'graphql-yoga'; import { execute } from 'testkit/graphql'; import { getServiceHost } from 'testkit/utils'; import { graphql } from '@app/gql'; import { OrganizationAccessScope, ProjectAccessScope, ProjectType, TargetAccessScope, } from '@app/gql/graphql'; // eslint-disable-next-line hive/enforce-deps-in-dev import { normalizeOperation } from '@graphql-hive/core'; import { createHive } from '../../../../packages/libraries/core/src'; import { clickHouseQuery } from '../../../testkit/clickhouse'; import { createTarget, updateTargetValidationSettings, waitFor } from '../../../testkit/flow'; import { initSeed } from '../../../testkit/seed'; import { CollectedOperation } from '../../../testkit/usage'; function ensureNumber(value: number | string): number { if (typeof value === 'number') { return value; } return parseFloat(value); } function prepareBatch(amount: number, operation: CollectedOperation) { return new Array(amount).fill(operation); } test.concurrent( 'collect operation and publish schema using WRITE access but read operations and check schema using READ access', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { createToken } = await createProject(ProjectType.Single); const settingsToken = await createToken({ targetScopes: [TargetAccessScope.Read, TargetAccessScope.Settings], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const readToken = await createToken({ targetScopes: [TargetAccessScope.Read, TargetAccessScope.RegistryRead], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const schemaPublishResult = await writeToken .publishSchema({ author: 'Kamil', commit: 'abc123', sdl: `type Query { ping: String me: String }`, }) .then(r => r.expectNoGraphQLErrors()); expect((schemaPublishResult.schemaPublish as any).valid).toEqual(true); const targetValidationResult = await settingsToken.toggleTargetValidation(true); expect(targetValidationResult.setTargetValidation.validationSettings.enabled).toEqual(true); expect(targetValidationResult.setTargetValidation.validationSettings.percentage).toEqual(0); expect(targetValidationResult.setTargetValidation.validationSettings.period).toEqual(30); // should not be breaking because the field is unused const unusedCheckResult = await readToken .checkSchema(`type Query { me: String }`) .then(r => r.expectNoGraphQLErrors()); expect(unusedCheckResult.schemaCheck.__typename).toEqual('SchemaCheckSuccess'); const collectResult = await writeToken.collectLegacyOperations([ { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); expect(collectResult.status).toEqual(200); await waitFor(5000); // should be breaking because the field is used now const usedCheckResult = await readToken .checkSchema(`type Query { me: String }`) .then(r => r.expectNoGraphQLErrors()); if (usedCheckResult.schemaCheck.__typename !== 'SchemaCheckError') { throw new Error(`Expected SchemaCheckError, got ${usedCheckResult.schemaCheck.__typename}`); } expect(usedCheckResult.schemaCheck.valid).toEqual(false); const from = formatISO(subHours(Date.now(), 6)); const to = formatISO(Date.now()); const operationsStats = await readToken.readOperationsStats(from, to); expect(operationsStats.operations.nodes).toHaveLength(1); const op = operationsStats.operations.nodes[0]; expect(op.count).toEqual(1); await expect(writeToken.readOperationBody(op.operationHash!)).resolves.toEqual( 'query ping{ping}', ); expect(op.operationHash).toBeDefined(); expect(op.duration.p75).toEqual(200); expect(op.duration.p90).toEqual(200); expect(op.duration.p95).toEqual(200); expect(op.duration.p99).toEqual(200); expect(op.kind).toEqual('query'); expect(op.name).toMatch('ping'); expect(op.percentage).toBeGreaterThan(99); }, ); test.concurrent('normalize and collect operation without breaking its syntax', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const raw_document = ` query outfit { recommendations( input: { strategies: [{ name: "asd" }] articleId: "asd" customerId: "asd" phoenixEnabled: true sessionId: "asd" } ) { ... on RecommendationResponse { frequentlyBoughtTogether { recommendedProducts { id } strategyMessage } outfit { strategyMessage } outfit { recommendedProducts { articleId id imageUrl name productUrl rating tCode } strategyMessage } similar { recommendedProducts { articleId id imageUrl name productUrl rating tCode } strategyMessage } visualSearch { strategyMessage } } } } `; const normalized_document = normalizeOperation({ document: parse(raw_document), operationName: 'outfit', hideLiterals: true, removeAliases: true, }); const collectResult = await writeToken.collectLegacyOperations([ { operation: normalizeOperation({ document: parse(raw_document), operationName: 'outfit', hideLiterals: true, removeAliases: true, }), operationName: 'outfit', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); expect(collectResult.status).toEqual(200); await waitFor(5000); const from = formatISO(subHours(Date.now(), 6)); const to = formatISO(Date.now()); const operationsStats = await writeToken.readOperationsStats(from, to); expect(operationsStats.operations.nodes).toHaveLength(1); const op = operationsStats.operations.nodes[0]; expect(op.count).toEqual(1); const doc = await writeToken.readOperationBody(op.operationHash!); if (!doc) { throw new Error('Operation body is empty'); } expect(() => { parse(doc); }).not.toThrow(); expect(print(parse(doc))).toEqual(print(parse(normalized_document))); expect(op.operationHash).toBeDefined(); expect(op.duration.p75).toEqual(200); expect(op.duration.p90).toEqual(200); expect(op.duration.p95).toEqual(200); expect(op.duration.p99).toEqual(200); expect(op.kind).toEqual('query'); expect(op.name).toMatch('outfit'); expect(op.percentage).toBeGreaterThan(99); }); test.concurrent( 'number of produced and collected operations should match (no errors)', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const batchSize = 1000; const totalAmount = 10_000; for await (const _ of new Array(totalAmount / batchSize)) { await writeToken.collectLegacyOperations( prepareBatch(batchSize, { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }), ); } await waitFor(5000); const from = formatISO(subHours(Date.now(), 6)); const to = formatISO(Date.now()); const operationsStats = await writeToken.readOperationsStats(from, to); // We sent a single operation (multiple times) expect(operationsStats.operations.nodes).toHaveLength(1); const op = operationsStats.operations.nodes[0]; expect(op.count).toEqual(totalAmount); await expect(writeToken.readOperationBody(op.operationHash!)).resolves.toEqual( 'query ping{ping}', ); expect(op.operationHash).toBeDefined(); expect(op.duration.p75).toEqual(200); expect(op.duration.p90).toEqual(200); expect(op.duration.p95).toEqual(200); expect(op.duration.p99).toEqual(200); expect(op.kind).toEqual('query'); expect(op.name).toMatch('ping'); expect(op.percentage).toBeGreaterThan(99); }, ); test.concurrent('check usage from two selected targets', async () => { const { createOrg, ownerToken } = await initSeed().createOwner(); const { organization, createProject } = await createOrg(); const { project, target: staging, createToken } = await createProject(ProjectType.Single); const productionTargetResult = await createTarget( { name: 'target2', organization: organization.cleanId, project: project.cleanId, }, ownerToken, ).then(r => r.expectNoGraphQLErrors()); expect(productionTargetResult.createTarget.error).toBeNull(); const productionTarget = productionTargetResult.createTarget.ok!.createdTarget; const stagingToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, TargetAccessScope.Settings, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read, OrganizationAccessScope.Settings], }); const productionToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], targetId: productionTarget.cleanId, }); const schemaPublishResult = await stagingToken .publishSchema({ author: 'Kamil', commit: 'usage-check-2', sdl: `type Query { ping: String me: String }`, }) .then(r => r.expectNoGraphQLErrors()); expect((schemaPublishResult.schemaPublish as any).valid).toEqual(true); const targetValidationResult = await stagingToken.toggleTargetValidation(true); expect(targetValidationResult.setTargetValidation.validationSettings.enabled).toEqual(true); expect(targetValidationResult.setTargetValidation.validationSettings.percentage).toEqual(0); expect(targetValidationResult.setTargetValidation.validationSettings.period).toEqual(30); const collectResult = await productionToken.collectLegacyOperations([ { timestamp: Date.now(), operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: {}, }, { timestamp: Date.now(), operation: 'query me { me }', operationName: 'me', fields: ['Query', 'Query.me'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { timestamp: Date.now(), operation: 'query me { me }', operationName: 'me', fields: ['Query', 'Query.me'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); expect(collectResult.status).toEqual(200); await waitFor(5000); // should not be breaking because the field is unused on staging // ping is used but on production const unusedCheckResult = await stagingToken .checkSchema(`type Query { me: String }`) .then(r => r.expectNoGraphQLErrors()); expect(unusedCheckResult.schemaCheck.__typename).toEqual('SchemaCheckSuccess'); // Now switch to using checking both staging and production const updateValidationResult = await updateTargetValidationSettings( { organization: organization.cleanId, project: project.cleanId, target: staging.cleanId, percentage: 50, // Out of 3 requests, 1 is for Query.me, 2 are done for Query.me so it's 1/3 = 33.3% period: 2, targets: [productionTarget.id, staging.id], }, { authToken: ownerToken, }, ).then(r => r.expectNoGraphQLErrors()); expect(updateValidationResult.updateTargetValidationSettings.error).toBeNull(); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings.percentage, ).toEqual(50); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings.period, ).toEqual(2); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings.targets, ).toHaveLength(2); // should be non-breaking because the field is used in production and we are checking staging and production now // and it used in less than 50% of traffic // ping is used on production and we do check production now const usedCheckResult = await stagingToken .checkSchema(`type Query { me: String }`) .then(r => r.expectNoGraphQLErrors()); if (usedCheckResult.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${usedCheckResult.schemaCheck.__typename}`); } expect(usedCheckResult.schemaCheck.valid).toEqual(true); }); test.concurrent('check usage not from excluded client names', async () => { const { createOrg, ownerToken } = await initSeed().createOwner(); const { organization, createProject } = await createOrg(); const { project, target, createToken } = await createProject(ProjectType.Single); const token = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, TargetAccessScope.Settings, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const schemaPublishResult = await token .publishSchema({ author: 'Kamil', commit: 'usage-check-2', sdl: `type Query { ping: String me: String }`, }) .then(r => r.expectNoGraphQLErrors()); expect((schemaPublishResult.schemaPublish as any).valid).toEqual(true); const targetValidationResult = await token.toggleTargetValidation(true); expect(targetValidationResult.setTargetValidation.validationSettings.enabled).toEqual(true); expect(targetValidationResult.setTargetValidation.validationSettings.percentage).toEqual(0); expect(targetValidationResult.setTargetValidation.validationSettings.period).toEqual(30); const collectResult = await token.collectLegacyOperations([ { timestamp: Date.now(), operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'cli', version: '2.0.0', }, }, }, { timestamp: Date.now(), operation: 'query me { me }', operationName: 'me', fields: ['Query', 'Query.me'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'app', version: '1.0.0', }, }, }, { timestamp: Date.now(), operation: 'query me { me }', operationName: 'me', fields: ['Query', 'Query.me'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'app', version: '1.0.1', }, }, }, { timestamp: Date.now(), operation: 'query me { me }', operationName: 'me', fields: ['Query', 'Query.me'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'cli', version: '2.0.0', }, }, }, ]); expect(collectResult.status).toEqual(200); await waitFor(5000); // should be breaking because the field is used // Query.me would be removed, but was requested by cli and app const unusedCheckResult = await token .checkSchema(`type Query { ping: String }`) .then(r => r.expectNoGraphQLErrors()); expect(unusedCheckResult.schemaCheck.__typename).toEqual('SchemaCheckError'); // Exclude app from the check (tests partial, incomplete exclusion) let updateValidationResult = await updateTargetValidationSettings( { organization: organization.cleanId, project: project.cleanId, target: target.cleanId, percentage: 0, period: 2, targets: [target.id], excludedClients: ['app'], }, { authToken: ownerToken, }, ).then(r => r.expectNoGraphQLErrors()); expect(updateValidationResult.updateTargetValidationSettings.error).toBeNull(); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings.enabled, ).toBe(true); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings .excludedClients, ).toHaveLength(1); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings .excludedClients, ).toContainEqual('app'); // should be unsafe because though we excluded 'app', 'cli' still uses this // Query.me would be removed, but was requested by cli and app const unusedCheckResult2 = await token .checkSchema(`type Query { ping: String }`) .then(r => r.expectNoGraphQLErrors()); expect(unusedCheckResult2.schemaCheck.__typename).toEqual('SchemaCheckError'); // Exclude BOTH 'app' and 'cli' (tests multi client covering exclusion) updateValidationResult = await updateTargetValidationSettings( { organization: organization.cleanId, project: project.cleanId, target: target.cleanId, percentage: 0, period: 2, targets: [target.id], excludedClients: ['app', 'cli'], }, { authToken: ownerToken, }, ).then(r => r.expectNoGraphQLErrors()); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings .excludedClients, ).toContainEqual('app'); expect( updateValidationResult.updateTargetValidationSettings.ok!.target.validationSettings .excludedClients, ).toContainEqual('cli'); // should be safe because the field was not used by the non-excluded clients // Query.me would be removed, but was requested by cli and app const usedCheckResult = await ( await token.checkSchema(`type Query { ping: String }`) ).expectNoGraphQLErrors(); if (usedCheckResult.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${usedCheckResult.schemaCheck.__typename}`); } expect(usedCheckResult.schemaCheck.valid).toEqual(true); }); describe('changes with usage data', () => { function testChangesWithUsageData(input: { title: string; publishSdl: string; checkSdl: string; reportOperation: { operation: string; operationName: string; fields: string[]; }; expectedSchemaCheckTypename: { beforeReportedOperation: 'SchemaCheckSuccess' | 'SchemaCheckError'; afterReportedOperation: 'SchemaCheckSuccess' | 'SchemaCheckError'; }; }) { test.concurrent(input.title, async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const token = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, TargetAccessScope.Settings, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], targetId: target.cleanId, }); const schemaPublishResult = await token .publishSchema({ author: 'Kamil', commit: 'initial', sdl: input.publishSdl, }) .then(r => r.expectNoGraphQLErrors()); expect((schemaPublishResult.schemaPublish as any).valid).toEqual(true); await expect( token .checkSchema(input.checkSdl) .then(r => r.expectNoGraphQLErrors()) .then(r => r.schemaCheck.__typename), ).resolves.toBe(input.expectedSchemaCheckTypename.beforeReportedOperation); const targetValidationResult = await token.toggleTargetValidation(true); expect(targetValidationResult.setTargetValidation.validationSettings.enabled).toEqual(true); expect(targetValidationResult.setTargetValidation.validationSettings.percentage).toEqual(0); expect(targetValidationResult.setTargetValidation.validationSettings.period).toEqual(30); const collectResult = await token.collectLegacyOperations([ { timestamp: Date.now(), operation: input.reportOperation.operation, operationName: input.reportOperation.operationName, fields: input.reportOperation.fields, execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: {}, }, ]); expect(collectResult.status).toEqual(200); await waitFor(5000); await expect( token .checkSchema(input.checkSdl) .then(r => r.expectNoGraphQLErrors()) .then(r => r.schemaCheck.__typename), ).resolves.toEqual(input.expectedSchemaCheckTypename.afterReportedOperation); }); } testChangesWithUsageData({ title: 'add non-nullable input field to used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int first: Int! } `, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, expectedSchemaCheckTypename: { // should be breaking because the input object type with new non-nullable field beforeReportedOperation: 'SchemaCheckError', // should be breaking because the input object type is used afterReportedOperation: 'SchemaCheckError', }, }); testChangesWithUsageData({ title: 'add nullable input field to used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int first: Int } `, expectedSchemaCheckTypename: { // should be safe, because it's nullable field and does not require user to provide it beforeReportedOperation: 'SchemaCheckSuccess', // should be safe, for the same reason afterReportedOperation: 'SchemaCheckSuccess', }, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, }); testChangesWithUsageData({ title: 'make nullable input field non-nullable of an used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int! } `, expectedSchemaCheckTypename: { // should be breaking, because it requires an action from user beforeReportedOperation: 'SchemaCheckError', // should be breaking, because it requires an action from user afterReportedOperation: 'SchemaCheckError', }, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, }); testChangesWithUsageData({ title: 'make non-nullable input nullable of an used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int! } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int } `, expectedSchemaCheckTypename: { // should be safe, as it does not require any action from user beforeReportedOperation: 'SchemaCheckSuccess', // should be safe, as it does not require any action from user afterReportedOperation: 'SchemaCheckSuccess', }, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, }); testChangesWithUsageData({ title: 'modify type of a non-nullable input field of an used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int skip: Int! } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int skip: String! } `, expectedSchemaCheckTypename: { // should be breaking, because it's non-nullable field beforeReportedOperation: 'SchemaCheckError', // should be safe. Even though it's non-nullable field and the input object type is used // BUT the field was NOT reported yet! afterReportedOperation: 'SchemaCheckSuccess', }, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, }); testChangesWithUsageData({ title: 'modify type of a nullable input field of an used input object', publishSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int skip: Int } `, checkSdl: /* GraphQL */ ` type Query { users(filter: Filter): [String] } input Filter { limit: Int skip: String } `, expectedSchemaCheckTypename: { // should be breaking, because it changes the type of the field beforeReportedOperation: 'SchemaCheckError', // should be safe, because Filter.skip is not used and it's nullable afterReportedOperation: 'SchemaCheckSuccess', }, reportOperation: { operation: 'query users { users(filter: { limit: 5 }) }', operationName: 'users', fields: ['Query', 'Query.users', 'Filter', 'Filter.limit'], }, }); }); test.concurrent('number of produced and collected operations should match', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const batchSize = 1000; const totalAmount = 10_000; for await (const i of new Array(totalAmount / batchSize).fill(null).map((_, i) => i)) { await writeToken.collectLegacyOperations( prepareBatch( batchSize, i % 2 === 0 ? { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, } : { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'web', version: '1.2.3', }, }, }, ), ); } await waitFor(5000); const result = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(` SELECT target, client_name, hash, sum(total) as total FROM clients_daily WHERE timestamp >= subtractDays(now(), 30) AND timestamp <= now() AND target = '${target.id}' GROUP BY target, client_name, hash `); expect(result.rows).toEqual(2); expect(result.data).toContainEqual( expect.objectContaining({ target: target.id, client_name: 'web', hash: expect.any(String), total: expect.stringMatching('5000'), }), ); expect(result.data).toContainEqual( expect.objectContaining({ target: target.id, client_name: '', hash: expect.any(String), total: expect.stringMatching('5000'), }), ); }); test.concurrent( 'different order of schema coordinates should not result in different hash', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); await writeToken.collectLegacyOperations([ { operation: 'query ping { ping }', // those spaces are expected and important to ensure normalization is in place operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query.ping', 'Query'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); await waitFor(5000); const coordinatesResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(` SELECT coordinate, hash FROM coordinates_daily WHERE target = '${target.id}' GROUP BY coordinate, hash `); expect(coordinatesResult.rows).toEqual(2); const operationCollectionResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(`SELECT hash FROM operation_collection WHERE target = '${target.id}' GROUP BY hash`); expect(operationCollectionResult.rows).toEqual(1); }, ); test.concurrent( 'same operation but with different schema coordinates should result in different hash', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); await writeToken.collectLegacyOperations([ { operation: 'query ping { ping }', // those spaces are expected and important to ensure normalization is in place operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { operation: 'query ping { ping }', operationName: 'ping', fields: ['RootQuery', 'RootQuery.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); await waitFor(5000); const coordinatesResult = await clickHouseQuery<{ coordinate: string; hash: string; }>(` SELECT coordinate, hash FROM coordinates_daily WHERE target = '${target.id}' GROUP BY coordinate, hash `); expect(coordinatesResult.rows).toEqual(4); const operationCollectionResult = await clickHouseQuery<{ hash: string; }>(`SELECT hash FROM operation_collection WHERE target = '${target.id}' GROUP BY hash`); expect(operationCollectionResult.rows).toEqual(2); const operationsResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(`SELECT hash FROM operation_collection WHERE target = '${target.id}' GROUP BY hash`); expect(operationsResult.rows).toEqual(2); }, ); test.concurrent( 'operations with the same schema coordinates and body but with different name should result in different hashes', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); await writeToken.collectLegacyOperations([ { operation: 'query pingv2 { ping }', operationName: 'pingv2', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); await waitFor(5000); const coordinatesResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(` SELECT coordinate, hash FROM coordinates_daily WHERE target = '${target.id}' GROUP BY coordinate, hash `); expect(coordinatesResult.rows).toEqual(4); const operationsResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(`SELECT hash FROM operation_collection WHERE target = '${target.id}' GROUP BY hash`); expect(operationsResult.rows).toEqual(2); }, ); test.concurrent('ignore operations with syntax errors', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const collectResult = await writeToken.collectLegacyOperations([ { operation: 'query pingv2 { pingv2 }', operationName: 'pingv2', fields: ['Query', 'Query.pingv2'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { operation: 'query ping ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, ]); expect(collectResult.status).toEqual(200); expect(typeof collectResult.body !== 'string' && collectResult.body.operations).toEqual( expect.objectContaining({ rejected: 1, accepted: 1, }), ); await waitFor(5000); const coordinatesResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(` SELECT coordinate, hash FROM coordinates_daily WHERE target = '${target.id}' GROUP BY coordinate, hash `); expect(coordinatesResult.rows).toEqual(2); const operationsResult = await clickHouseQuery<{ target: string; client_name: string | null; hash: string; total: number; }>(`SELECT hash FROM operation_collection WHERE target = '${target.id}' GROUP BY hash`); expect(operationsResult.rows).toEqual(1); }); test.concurrent('ensure correct data', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { target, createToken } = await createProject(ProjectType.Single); const writeToken = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); await writeToken.collectLegacyOperations([ { operation: 'query ping { ping }', // those spaces are expected and important to ensure normalization is in place operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, }, { operation: 'query ping { ping }', operationName: 'ping', fields: ['Query', 'Query.ping'], execution: { ok: true, duration: 200_000_000, errorsTotal: 0, }, metadata: { client: { name: 'test-name', version: 'test-version', }, }, }, ]); await waitFor(5000); // operation_collection const operationCollectionResult = await clickHouseQuery<{ target: string; hash: string; name: string; body: string; operation_kind: string; coordinates: string[]; total: string; timestamp: string; expires_at: string; }>(` SELECT target, hash, name, body, operation_kind, sum(total) as total, coordinates FROM operation_collection WHERE target = '${target.id}' GROUP BY target, hash, coordinates, name, body, operation_kind `); expect(operationCollectionResult.data).toHaveLength(1); const operationCollectionRow = operationCollectionResult.data[0]; expect(operationCollectionRow.body).toEqual('query ping{ping}'); expect(operationCollectionRow.coordinates).toHaveLength(2); expect(operationCollectionRow.coordinates).toContainEqual('Query.ping'); expect(operationCollectionRow.coordinates).toContainEqual('Query'); expect(operationCollectionRow.hash).toHaveLength(32); expect(operationCollectionRow.name).toBe('ping'); expect(operationCollectionRow.target).toBe(target.id); expect(ensureNumber(operationCollectionRow.total)).toEqual(2); // operations const operationsResult = await clickHouseQuery<{ target: string; timestamp: string; expires_at: string; hash: string; ok: boolean; errors: number; duration: number; client_name: string; client_version: string; }>(` SELECT target, timestamp, expires_at, hash, ok, errors, duration, client_name, client_version FROM operations WHERE target = '${target.id}' `); expect(operationsResult.data).toHaveLength(2); const operationWithClient = operationsResult.data.find(o => o.client_name.length > 0)!; expect(operationWithClient).toBeDefined(); expect(operationWithClient.client_name).toEqual('test-name'); expect(operationWithClient.client_version).toEqual('test-version'); expect(ensureNumber(operationWithClient.duration)).toEqual(200_000_000); expect(ensureNumber(operationWithClient.errors)).toEqual(0); expect(operationWithClient.hash).toHaveLength(32); expect(operationWithClient.target).toEqual(target.id); const operationWithoutClient = operationsResult.data.find(o => o.client_name.length === 0)!; expect(operationWithoutClient).toBeDefined(); expect(operationWithoutClient.client_name).toHaveLength(0); expect(operationWithoutClient.client_version).toHaveLength(0); expect(ensureNumber(operationWithoutClient.duration)).toEqual(200_000_000); expect(ensureNumber(operationWithoutClient.errors)).toEqual(0); expect(operationWithoutClient.hash).toHaveLength(32); expect(operationWithoutClient.target).toEqual(target.id); // operations_hourly const operationsHourlyResult = await clickHouseQuery<{ target: string; hash: string; total_ok: string; total: string; quantiles: [number]; }>(` SELECT target, sum(total) as total, sum(total_ok) as total_ok, hash, quantilesMerge(0.99)(duration_quantiles) as quantiles FROM operations_hourly WHERE target = '${target.id}' GROUP BY target, hash `); expect(operationsHourlyResult.data).toHaveLength(1); const hourlyAgg = operationsHourlyResult.data[0]; expect(hourlyAgg).toBeDefined(); expect(ensureNumber(hourlyAgg.quantiles[0])).toEqual(200_000_000); expect(ensureNumber(hourlyAgg.total)).toEqual(2); expect(ensureNumber(hourlyAgg.total_ok)).toEqual(2); expect(hourlyAgg.hash).toHaveLength(32); expect(hourlyAgg.target).toEqual(target.id); // operations_daily const operationsDailyResult = await clickHouseQuery<{ target: string; hash: string; total_ok: string; total: string; quantiles: [number]; }>(` SELECT target, sum(total) as total, sum(total_ok) as total_ok, hash, quantilesMerge(0.99)(duration_quantiles) as quantiles FROM operations_daily WHERE target = '${target.id}' GROUP BY target, hash `); expect(operationsDailyResult.data).toHaveLength(1); const dailyAgg = operationsDailyResult.data[0]; expect(dailyAgg).toBeDefined(); expect(ensureNumber(dailyAgg.quantiles[0])).toEqual(200_000_000); expect(ensureNumber(dailyAgg.total)).toEqual(2); expect(ensureNumber(dailyAgg.total_ok)).toEqual(2); expect(dailyAgg.hash).toHaveLength(32); expect(dailyAgg.target).toEqual(target.id); // coordinates_daily const coordinatesDailyResult = await clickHouseQuery<{ target: string; hash: string; total: string; coordinate: string; }>(` SELECT target, sum(total) as total, hash, coordinate FROM coordinates_daily WHERE target = '${target.id}' GROUP BY target, hash, coordinate `); expect(coordinatesDailyResult.data).toHaveLength(2); const rootCoordinate = coordinatesDailyResult.data.find(c => c.coordinate === 'Query')!; expect(rootCoordinate).toBeDefined(); expect(ensureNumber(rootCoordinate.total)).toEqual(2); expect(rootCoordinate.hash).toHaveLength(32); expect(rootCoordinate.target).toEqual(target.id); const fieldCoordinate = coordinatesDailyResult.data.find(c => c.coordinate === 'Query.ping')!; expect(fieldCoordinate).toBeDefined(); expect(ensureNumber(fieldCoordinate.total)).toEqual(2); expect(fieldCoordinate.hash).toHaveLength(32); expect(fieldCoordinate.target).toEqual(target.id); // clients_daily const clientsDailyResult = await clickHouseQuery<{ target: string; hash: string; client_name: string; client_version: string; total: string; }>(` SELECT target, sum(total) as total, hash, client_name, client_version FROM clients_daily WHERE target = '${target.id}' GROUP BY target, hash, client_name, client_version `); expect(clientsDailyResult.data).toHaveLength(2); const dailyAggOfKnownClient = clientsDailyResult.data.find(c => c.client_name === 'test-name')!; expect(dailyAggOfKnownClient).toBeDefined(); expect(ensureNumber(dailyAggOfKnownClient.total)).toEqual(1); expect(dailyAggOfKnownClient.client_version).toBe('test-version'); expect(dailyAggOfKnownClient.hash).toHaveLength(32); expect(dailyAggOfKnownClient.target).toEqual(target.id); const dailyAggOfUnknownClient = clientsDailyResult.data.find(c => c.client_name !== 'test-name')!; expect(dailyAggOfUnknownClient).toBeDefined(); expect(ensureNumber(dailyAggOfUnknownClient.total)).toEqual(1); expect(dailyAggOfUnknownClient.client_version).toHaveLength(0); expect(dailyAggOfUnknownClient.hash).toHaveLength(32); expect(dailyAggOfUnknownClient.target).toEqual(target.id); }); const SubscriptionSchemaCheckQuery = graphql(/* GraphQL */ ` query SubscriptionSchemaCheck($selector: TargetSelectorInput!, $id: ID!) { target(selector: $selector) { schemaCheck(id: $id) { __typename id breakingSchemaChanges { nodes { criticality criticalityReason message path isSafeBasedOnUsage usageStatistics { topAffectedOperations { hash name countFormatted percentageFormatted } topAffectedClients { name countFormatted percentageFormatted } } approval { schemaCheckId approvedAt approvedBy { id displayName } } } } } } } `); test.concurrent('test threshold when using conditional breaking change detection', async () => { const { createOrg } = await initSeed().createOwner(); const { createProject } = await createOrg(); const { createToken } = await createProject(ProjectType.Single); const token = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, TargetAccessScope.Settings, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const sdl = /* GraphQL */ ` type Query { a: String b: String c: String } `; const queryA = parse(/* GraphQL */ ` query { a } `); const queryB = parse(/* GraphQL */ ` query { b } `); function collectA() { client.collectUsage()( { document: queryA, schema, contextValue: { request, }, }, {}, ); } function collectB() { client.collectUsage()( { document: queryB, schema, contextValue: { request, }, }, {}, ); } const schema = buildASTSchema(parse(sdl)); const schemaPublishResult = await token .publishSchema({ sdl, author: 'Kamil', commit: 'initial', }) .then(res => res.expectNoGraphQLErrors()); expect(schemaPublishResult.schemaPublish.__typename).toEqual('SchemaPublishSuccess'); await token.toggleTargetValidation(true); const unused = await token .checkSchema(/* GraphQL */ ` type Query { b: String c: String } `) .then(r => r.expectNoGraphQLErrors()); if (unused.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${unused.schemaCheck.__typename}`); } expect(unused.schemaCheck.changes).toEqual( expect.objectContaining({ nodes: expect.arrayContaining([ expect.objectContaining({ message: "Field 'a' was removed from object type 'Query' (non-breaking based on usage)", }), ]), total: 1, }), ); const usageAddress = await getServiceHost('usage', 8081); const client = createHive({ enabled: true, token: token.secret, usage: true, debug: false, agent: { logger: createLogger('debug'), maxSize: 1, }, selfHosting: { usageEndpoint: 'http://' + usageAddress, graphqlEndpoint: 'http://noop/', applicationUrl: 'http://noop/', }, }); const request = new Request('http://localhost:4000/graphql', { method: 'POST', headers: { 'x-graphql-client-name': 'integration-tests', 'x-graphql-client-version': '6.6.6', }, }); collectA(); await waitFor(5000); const used = await token .checkSchema(/* GraphQL */ ` type Query { b: String c: String } `) .then(r => r.expectNoGraphQLErrors()); if (used.schemaCheck.__typename !== 'SchemaCheckError') { throw new Error(`Expected SchemaCheckError, got ${used.schemaCheck.__typename}`); } expect(used.schemaCheck.errors).toEqual({ nodes: [ { message: "Field 'a' was removed from object type 'Query'", }, ], total: 1, }); // Now let's make Query.a below threshold by making 3 queries for Query.b collectB(); collectB(); collectB(); await token.updateTargetValidationSettings({ excludedClients: [], percentage: 50, }); await waitFor(5000); const below = await token .checkSchema(/* GraphQL */ ` type Query { b: String c: String } `) .then(r => r.expectNoGraphQLErrors()); if (below.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${below.schemaCheck.__typename}`); } expect(below.schemaCheck.changes).toEqual( expect.objectContaining({ nodes: expect.arrayContaining([ expect.objectContaining({ message: "Field 'a' was removed from object type 'Query' (non-breaking based on usage)", }), ]), total: 1, }), ); // Make it above threshold again, by making 3 queries for Query.a collectA(); collectA(); collectA(); await waitFor(5000); const relevant = await token .checkSchema(/* GraphQL */ ` type Query { b: String c: String } `) .then(r => r.expectNoGraphQLErrors()); if (relevant.schemaCheck.__typename !== 'SchemaCheckError') { throw new Error(`Expected SchemaCheckError, got ${relevant.schemaCheck.__typename}`); } expect(relevant.schemaCheck.errors).toEqual({ nodes: [ { message: "Field 'a' was removed from object type 'Query'", }, ], total: 1, }); }); test.concurrent( 'subscription operation is used for conditional breaking change detection', async () => { const { createOrg } = await initSeed().createOwner(); const { organization, createProject } = await createOrg(); const { project, target, createToken } = await createProject(ProjectType.Single); const token = await createToken({ targetScopes: [ TargetAccessScope.Read, TargetAccessScope.RegistryRead, TargetAccessScope.RegistryWrite, TargetAccessScope.Settings, ], projectScopes: [ProjectAccessScope.Read], organizationScopes: [OrganizationAccessScope.Read], }); const sdl = /* GraphQL */ ` type Query { a: String b: String } type Subscription { a: String b: String } `; const schema = buildASTSchema(parse(sdl)); const schemaPublishResult = await token .publishSchema({ sdl, author: 'Kamil', commit: 'initial', }) .then(res => res.expectNoGraphQLErrors()); expect(schemaPublishResult.schemaPublish.__typename).toEqual('SchemaPublishSuccess'); await token.toggleTargetValidation(true); const unused = await token .checkSchema(/* GraphQL */ ` type Query { a: String b: String } type Subscription { b: String } `) .then(r => r.expectNoGraphQLErrors()); if (unused.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${unused.schemaCheck.__typename}`); } expect(unused.schemaCheck.changes).toEqual( expect.objectContaining({ nodes: expect.arrayContaining([ expect.objectContaining({ message: "Field 'a' was removed from object type 'Subscription' (non-breaking based on usage)", }), ]), total: 1, }), ); const usageAddress = await getServiceHost('usage', 8081); const client = createHive({ enabled: true, token: token.secret, usage: true, debug: false, agent: { logger: createLogger('debug'), maxSize: 1, }, selfHosting: { usageEndpoint: 'http://' + usageAddress, graphqlEndpoint: 'http://noop/', applicationUrl: 'http://noop/', }, }); const request = new Request('http://localhost:4000/graphql', { method: 'POST', headers: { 'x-graphql-client-name': 'integration-tests', 'x-graphql-client-version': '6.6.6', }, }); client.collectSubscriptionUsage({ args: { document: parse(/* GraphQL */ ` subscription { a } `), schema, contextValue: { request, }, }, }); await waitFor(5000); const used = await token .checkSchema(/* GraphQL */ ` type Query { a: String b: String } type Subscription { b: String } `) .then(r => r.expectNoGraphQLErrors()); if (used.schemaCheck.__typename !== 'SchemaCheckError') { throw new Error(`Expected SchemaCheckError, got ${used.schemaCheck.__typename}`); } expect(used.schemaCheck.errors).toEqual({ nodes: [ { message: "Field 'a' was removed from object type 'Subscription'", }, ], total: 1, }); const firstSchemaCheckId = used.schemaCheck.schemaCheck?.id; if (!firstSchemaCheckId) { throw new Error('Expected schemaCheckId to be defined'); } const firstSchemaCheck = await execute({ document: SubscriptionSchemaCheckQuery, variables: { id: firstSchemaCheckId, selector: { organization: organization.cleanId, project: project.cleanId, target: target.cleanId, }, }, authToken: token.secret, }).then(r => r.expectNoGraphQLErrors()); const node = firstSchemaCheck.target?.schemaCheck?.breakingSchemaChanges?.nodes[0]; if (!node) { throw new Error('Expected node to be defined'); } expect(node.isSafeBasedOnUsage).toEqual(false); expect(node.usageStatistics?.topAffectedOperations).toEqual([ { countFormatted: '1', hash: 'c1bbc8385a4a6f4e4988be7394800adc', name: 'anonymous', percentageFormatted: '100.00%', }, ]); expect(node.usageStatistics?.topAffectedClients).toEqual([ { countFormatted: '1', name: 'integration-tests', percentageFormatted: '100.00%', }, ]); // Now let's make subscription insignificant by making 3 queries client.collectUsage()( { document: parse(/* GraphQL */ ` query { a } `), schema, contextValue: { request, }, }, {}, ); client.collectUsage()( { document: parse(/* GraphQL */ ` query { a } `), schema, contextValue: { request, }, }, {}, ); client.collectUsage()( { document: parse(/* GraphQL */ ` query { a } `), schema, contextValue: { request, }, }, {}, ); await token.updateTargetValidationSettings({ excludedClients: [], percentage: 50, }); await waitFor(5000); const irrelevant = await token .checkSchema(/* GraphQL */ ` type Query { a: String b: String } type Subscription { b: String } `) .then(r => r.expectNoGraphQLErrors()); if (irrelevant.schemaCheck.__typename !== 'SchemaCheckSuccess') { throw new Error(`Expected SchemaCheckSuccess, got ${irrelevant.schemaCheck.__typename}`); } expect(irrelevant.schemaCheck.changes).toEqual( expect.objectContaining({ nodes: expect.arrayContaining([ expect.objectContaining({ message: "Field 'a' was removed from object type 'Subscription' (non-breaking based on usage)", }), ]), total: 1, }), ); // Make it relevant again, by making 3 subscriptions client.collectSubscriptionUsage({ args: { document: parse(/* GraphQL */ ` subscription { a } `), schema, contextValue: { request, }, }, }); client.collectSubscriptionUsage({ args: { document: parse(/* GraphQL */ ` subscription { a } `), schema, contextValue: { request, }, }, }); client.collectSubscriptionUsage({ args: { document: parse(/* GraphQL */ ` subscription { a } `), schema, contextValue: { request, }, }, }); await waitFor(5000); const relevant = await token .checkSchema(/* GraphQL */ ` type Query { a: String b: String } type Subscription { b: String } `) .then(r => r.expectNoGraphQLErrors()); if (relevant.schemaCheck.__typename !== 'SchemaCheckError') { throw new Error(`Expected SchemaCheckError, got ${relevant.schemaCheck.__typename}`); } expect(relevant.schemaCheck.errors).toEqual({ nodes: [ { message: "Field 'a' was removed from object type 'Subscription'", }, ], total: 1, }); }, );