Elgato_dark/console
1
0
Fork 0
mirror of https://github.com/graphql-hive/console synced 2026-04-29 18:37:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
console/packages/services/usage/__tests__/usage-processor-2-validation.spec.ts

1058 lines
21 KiB
TypeScript
Raw Blame History

import { decodeReport } from '../src/usage-processor-2';
test('correct operation should be valid', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {
client: {
name: 'clientName',
version: 'clientVersion',
},
},
},
],
}),
).toMatchObject({ success: true });
});
test('$.map.metadata.client can be missing, undefined or null', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {
client: undefined,
},
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {
client: null,
},
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {},
},
],
}),
).toMatchObject({ success: true });
});
test('$.map.metadata can be missing, undefined or null', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: undefined,
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: null,
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({ success: true });
});
test('$.map.operationName can be missing, undefined or null', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: undefined,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: null,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({ success: true });
});
test('$.operations can be missing, undefined or null', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'subscription op1Name { field1 }',
fields: ['Subscription.field1'],
},
},
subscriptionOperations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'subscription op1Name { field1 }',
fields: ['Subscription.field1'],
},
},
operations: undefined,
subscriptionOperations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'subscription op1Name { field1 }',
fields: ['Subscription.field1'],
},
},
operations: null,
subscriptionOperations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
},
],
}),
).toMatchObject({ success: true });
});
test('$.subscriptionOperations can be missing, undefined or null', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
fields: ['query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
fields: ['query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
subscriptionOperations: undefined,
}),
).toMatchObject({ success: true });
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
fields: ['query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
subscriptionOperations: null,
}),
).toMatchObject({ success: true });
});
test('$.operations.metadata.client.version is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {
client: {
name: 'clientName',
},
},
},
],
}),
).toMatchObject({ success: false });
});
test('$.operations.metadata.client.name is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: 'query op1Name { field1 }',
operationName: 'op1Name',
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
metadata: {
client: {
version: 'clientVersion',
},
},
},
],
}),
).toMatchObject({ success: false });
});
test('$.map.operation is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: undefined,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: null,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
});
test('$.map.operation.fields is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: null,
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: undefined,
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: [],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
});
test('$.operations.execution.ok is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: undefined,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: null,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: 'true',
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: 1,
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
duration: 123456789,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
});
test('$.operations.execution.duration is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: undefined,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: null,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: '1234567890',
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: true,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
errorsTotal: 0,
},
},
],
}),
).toMatchObject({
success: false,
});
});
test('$.operations.execution.errorsTotal is required', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: undefined,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: null,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: '0',
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
errorsTotal: true,
},
},
],
}),
).toMatchObject({
success: false,
});
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: Date.now(),
execution: {
ok: true,
duration: 123456789,
},
},
],
}),
).toMatchObject({
success: false,
});
});
test('invalid duration and timestamp (-1) gives helpful error response', () => {
expect(
decodeReport({
size: 1,
map: {
op1Key: {
operation: `query op1Name { field1 }`,
fields: ['Query.field1'],
},
},
operations: [
{
operationMapKey: 'op1Key',
timestamp: -1,
execution: {
ok: true,
duration: -1,
errorsTotal: 1,
},
},
],
}),
).toEqual({
errors: [
{
errors: [
{
message: 'Expected valid unix timestamp in milliseconds',
path: '/operations/0/timestamp',
},
{
message: 'Expected integer to be greater or equal to 0',
path: '/operations/0/execution/duration',
},
{
message: 'Expected null',
path: '/operations',
},
],
message: 'Expected union value',
path: '/operations',
},
],
success: false,
});
});
Reference in a new issue View git blame Copy permalink