Skip to content

add additional runtime errors for pre-coercion OneOf errors #4195

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
yaacovCR wants to merge 10 commits into
base: next
Choose a base branch
from
Open

add additional runtime errors for pre-coercion OneOf errors #4195

Changes from 1 commit
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
136cde0
add runtime errors for pre-coercion OneOf errors
yaacovCR Sep 18, 2024
70e5c4f
only return a single error per value
yaacovCR Sep 18, 2024
5feb200
combine number of fields and nullability into uniform error message
yaacovCR Sep 18, 2024
d4d1bcb
don't capitalize "Type"
yaacovCR Sep 20, 2024
d6fe83b
fix extra word/capitalization with Within
yaacovCR Sep 20, 2024
20f8734
fix indentation
yaacovCR Sep 21, 2024
15a67e8
move final oneOf tests into variables-test.ts
yaacovCR Sep 21, 2024
d9342ba
add non-normative note
yaacovCR Sep 21, 2024
f2a6e9d
add less than one value case
yaacovCR Sep 21, 2024
cdd0b55
Apply suggestions from code review
benjie Oct 17, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
fix indentation
  • Loading branch information
@yaacovCR
yaacovCR committed Sep 21, 2024
commit 20f873459d42d420c0874f7c9a666c59b118e817
308 changes: 154 additions & 154 deletions src/execution/__tests__/variables-test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1144,189 +1144,189 @@ describe('Execute: Handles inputs', () => {
},
});
});
});

it('errors with OneOf Input Object with more than one field', () => {
const result = executeQuery(`
{
fieldWithOneOfObjectInput(input: { a: "abc", b: 123 })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
errors: [
it('errors with OneOf Input Object with more than one field', () => {
const result = executeQuery(`
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: "abc", b: 123 }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 42 }],
fieldWithOneOfObjectInput(input: { a: "abc", b: 123 })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
],
errors: [
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: "abc", b: 123 }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 44 }],
},
],
});
});
});

it('errors with OneOf Input Object with a single null value', () => {
const result = executeQuery(`
{
fieldWithOneOfObjectInput(input: { a: null })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
errors: [
it('errors with OneOf Input Object with a single null value', () => {
const result = executeQuery(`
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: null }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 42 }],
fieldWithOneOfObjectInput(input: { a: null })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
],
errors: [
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: null }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 44 }],
},
],
});
});
});

it('errors with OneOf Input Object with multiple values, only one non-null', () => {
const result = executeQuery(`
{
fieldWithOneOfObjectInput(input: { a: "abc", b: null })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
errors: [
it('errors with OneOf Input Object with multiple values, only one non-null', () => {
const result = executeQuery(`
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: "abc", b: null }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 42 }],
fieldWithOneOfObjectInput(input: { a: "abc", b: null })
}
`);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: null,
},
],
errors: [
{
message:
'Argument "input" of type "TestOneOfInputObject" has invalid value { a: "abc", b: null }.',
path: ['fieldWithOneOfObjectInput'],
locations: [{ line: 3, column: 44 }],
},
],
});
});
});

it('allows a variable for the entire OneOf Object with a single value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc' } },
);
it('allows a variable for the entire OneOf Object with a single value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc' } },
);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: '{ a: "abc" }',
},
expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: '{ a: "abc" }',
},
});
});
});

it('allows a variable for the entire OneOf Object with a single defined value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: undefined } },
);
it('allows a variable for the entire OneOf Object with a single defined value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: undefined } },
);

expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: '{ a: "abc" }',
},
expectJSON(result).toDeepEqual({
data: {
fieldWithOneOfObjectInput: '{ a: "abc" }',
},
});
});
});

it('errors with variable with no value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: {} },
);
it('errors with variable with no value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: {} },
);

expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value {}; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 16 }],
},
],
expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value {}; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 18 }],
},
],
});
});
});

it('errors with variable with multiple values', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: 123 } },
);
it('errors with variable with multiple values', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: 123 } },
);

expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value { a: "abc", b: 123 }; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 16 }],
},
],
expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value { a: "abc", b: 123 }; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 18 }],
},
],
});
});
});

it('errors with variable with single null value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: null } },
);
it('errors with variable with single null value', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: null } },
);

expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value null at "input.a"; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 16 }],
},
],
expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value null at "input.a"; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 18 }],
},
],
});
});
});

it('errors with variable with multiple values, only one non-null', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: null } },
);
it('errors with variable with multiple values, only one non-null', () => {
const result = executeQuery(
`
query ($input: TestOneOfInputObject) {
fieldWithOneOfObjectInput(input: $input)
}
`,
{ input: { a: 'abc', b: null } },
);

expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value { a: "abc", b: null }; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 16 }],
},
],
expectJSON(result).toDeepEqual({
errors: [
{
message:
'Variable "$input" got invalid value { a: "abc", b: null }; Within OneOf Input Object type "TestOneOfInputObject", exactly one field must be specified, and the value for that field must be non-null.',
locations: [{ line: 2, column: 18 }],
},
],
});
});
});

Expand Down