From 2feb9f6816c5a166309d012b03b40839758b0e1a Mon Sep 17 00:00:00 2001 From: Ivan Goncharov Date: Sat, 7 Apr 2018 23:45:55 +0300 Subject: [PATCH 1/5] Simplify non-null tests --- src/execution/__tests__/nonnull-test.js | 66 ++++++++++++------------- 1 file changed, 31 insertions(+), 35 deletions(-) diff --git a/src/execution/__tests__/nonnull-test.js b/src/execution/__tests__/nonnull-test.js index 58aef906b0..93ebae0fcc 100644 --- a/src/execution/__tests__/nonnull-test.js +++ b/src/execution/__tests__/nonnull-test.js @@ -108,6 +108,10 @@ const schema = new GraphQLSchema({ query: dataType, }); +function executeQuery(doc, rootValue) { + return execute(schema, parse(doc), rootValue); +} + // avoids also doing any nests function patch(data) { return JSON.parse( @@ -118,43 +122,35 @@ function patch(data) { } function check(description, syncOnly, doc, expectedReturn, expectedThrow) { - const descs = [ - [ - { - doc, - words: 'returns null', - data: nullingData, - expected: expectedReturn, - sync: 'synchronously', - }, - { - doc, - words: 'throws', - data: throwingData, - expected: { data: expectedReturn.data, ...expectedThrow }, - sync: 'synchronously', - }, - ], - ]; + it(description + ' that returns null synchronously', async () => { + const result = await executeQuery(doc, nullingData); + expect(result).to.containSubset(expectedReturn); + }); + + it(description + ' that throws synchronously', async () => { + const result = await executeQuery(doc, throwingData); + expect(result).to.containSubset({ + data: expectedReturn.data, + ...expectedThrow, + }); + }); + if (!syncOnly) { - descs.push( - descs[0].map(d => ({ - ...d, - doc: patch(d.doc), - expected: patch(d.expected), - sync: 'in a promise', - })), - ); + it(description + ' that returns null in a promise', async () => { + const result = await executeQuery(patch(doc), nullingData); + expect(result).to.containSubset(patch(expectedReturn)); + }); + + it(description + ' that throws in a promise', async () => { + const result = await executeQuery(patch(doc), throwingData); + expect(result).to.containSubset( + patch({ + data: expectedReturn.data, + ...expectedThrow, + }), + ); + }); } - descs.forEach(desc => - desc.forEach(desc2 => - it(description + ' that ' + desc2.words + ' ' + desc2.sync, async () => - expect( - await execute(schema, parse(desc2.doc), desc2.data), - ).to.containSubset(desc2.expected), - ), - ), - ); } describe('Execute: handles non-nullable types', () => { From 3dcce8f0737c96cc2ac3f7f26878d08e653c3186 Mon Sep 17 00:00:00 2001 From: Ivan Goncharov Date: Mon, 9 Apr 2018 19:00:16 +0300 Subject: [PATCH 2/5] Remove 'check' function and write test directly --- src/execution/__tests__/nonnull-test.js | 564 ++++++++++++------------ 1 file changed, 277 insertions(+), 287 deletions(-) diff --git a/src/execution/__tests__/nonnull-test.js b/src/execution/__tests__/nonnull-test.js index 93ebae0fcc..f0c35c5203 100644 --- a/src/execution/__tests__/nonnull-test.js +++ b/src/execution/__tests__/nonnull-test.js @@ -108,8 +108,8 @@ const schema = new GraphQLSchema({ query: dataType, }); -function executeQuery(doc, rootValue) { - return execute(schema, parse(doc), rootValue); +function executeQuery(query, rootValue) { + return execute(schema, parse(query), rootValue); } // avoids also doing any nests @@ -121,244 +121,215 @@ function patch(data) { ); } -function check(description, syncOnly, doc, expectedReturn, expectedThrow) { - it(description + ' that returns null synchronously', async () => { - const result = await executeQuery(doc, nullingData); - expect(result).to.containSubset(expectedReturn); - }); - - it(description + ' that throws synchronously', async () => { - const result = await executeQuery(doc, throwingData); - expect(result).to.containSubset({ - data: expectedReturn.data, - ...expectedThrow, - }); - }); - - if (!syncOnly) { - it(description + ' that returns null in a promise', async () => { - const result = await executeQuery(patch(doc), nullingData); - expect(result).to.containSubset(patch(expectedReturn)); - }); +async function executeSyncAndAsync(query, rootValue) { + const syncResult = await executeQuery(query, rootValue); + const asyncResult = await executeQuery(patch(query), rootValue); - it(description + ' that throws in a promise', async () => { - const result = await executeQuery(patch(doc), throwingData); - expect(result).to.containSubset( - patch({ - data: expectedReturn.data, - ...expectedThrow, - }), - ); - }); - } + expect(asyncResult).to.deep.equal(patch(syncResult)); + return syncResult; } describe('Execute: handles non-nullable types', () => { - check( - 'nulls a nullable field', - false, - ` - query Q { + describe('nulls a nullable field', () => { + const query = ` + { sync } - `, - { - data: { - sync: null, - }, - }, - { - errors: [ - { - message: syncError.message, - locations: [{ line: 3, column: 9 }], - }, - ], - }, - ); + `; + + it('that returns null', async () => { + const result = await executeSyncAndAsync(query, nullingData); + expect(result).to.containSubset({ + data: { sync: null }, + }); + }); + + it('that throws', async () => { + const result = await executeSyncAndAsync(query, throwingData); + expect(result).to.containSubset({ + data: { sync: null }, + errors: [ + { + message: syncError.message, + locations: [{ line: 3, column: 9 }], + }, + ], + }); + }); + }); - check( - 'nulls a synchronously returned object that contains a non-nullable field', - false, - ` - query Q { + describe('nulls a synchronously returned object that contains a non-nullable field', () => { + const query = ` + { syncNest { syncNonNull, } } - `, - { - data: { - syncNest: null, - }, - errors: [ - { - message: - 'Cannot return null for non-nullable field DataType.syncNonNull.', - locations: [{ line: 4, column: 11 }], - }, - ], - }, - { - errors: [ - { - message: syncNonNullError.message, - locations: [{ line: 4, column: 11 }], - }, - ], - }, - ); + `; + + it('that returns null', async () => { + const result = await executeSyncAndAsync(query, nullingData); + expect(result).to.containSubset({ + data: { syncNest: null }, + errors: [ + { + message: + 'Cannot return null for non-nullable field DataType.syncNonNull.', + locations: [{ line: 4, column: 11 }], + }, + ], + }); + }); - check( - 'nulls an object returned in a promise that contains a non-nullable field', - false, - ` - query Q { + it('that throws', async () => { + const result = await executeSyncAndAsync(query, throwingData); + expect(result).to.containSubset({ + data: { syncNest: null }, + errors: [ + { + message: syncNonNullError.message, + locations: [{ line: 4, column: 11 }], + }, + ], + }); + }); + }); + + describe('nulls an object returned in a promise that contains a non-nullable field', () => { + const query = ` + { promiseNest { syncNonNull, } } - `, - { - data: { - promiseNest: null, - }, - errors: [ - { - message: - 'Cannot return null for non-nullable field DataType.syncNonNull.', - locations: [{ line: 4, column: 11 }], - }, - ], - }, - { - errors: [ - { - message: syncNonNullError.message, - locations: [{ line: 4, column: 11 }], - }, - ], - }, - ); + `; + + it('that returns null', async () => { + const result = await executeSyncAndAsync(query, nullingData); + expect(result).to.containSubset({ + data: { promiseNest: null }, + errors: [ + { + message: + 'Cannot return null for non-nullable field DataType.syncNonNull.', + locations: [{ line: 4, column: 11 }], + }, + ], + }); + }); + + it('that throws', async () => { + const result = await executeSyncAndAsync(query, throwingData); + expect(result).to.containSubset({ + data: { promiseNest: null }, + errors: [ + { + message: syncNonNullError.message, + locations: [{ line: 4, column: 11 }], + }, + ], + }); + }); + }); - check( - 'nulls a complex tree of nullable fields, each', - true, - ` - query Q { + describe('nulls a complex tree of nullable fields, each', () => { + const query = ` + { syncNest { sync promise - syncNest { - sync - promise - } - promiseNest { - sync - promise - } + syncNest { sync promise } + promiseNest { sync promise } } promiseNest { sync promise - syncNest { - sync - promise - } - promiseNest { - sync - promise - } + syncNest { sync promise } + promiseNest { sync promise } } } - `, - { - data: { - syncNest: { - sync: null, - promise: null, - syncNest: { - sync: null, - promise: null, - }, - promiseNest: { - sync: null, - promise: null, + `; + const data = { + syncNest: { + sync: null, + promise: null, + syncNest: { sync: null, promise: null }, + promiseNest: { sync: null, promise: null }, + }, + promiseNest: { + sync: null, + promise: null, + syncNest: { sync: null, promise: null }, + promiseNest: { sync: null, promise: null }, + }, + }; + + it('that returns null', async () => { + const result = await executeQuery(query, nullingData); + expect(result).to.containSubset({ data }); + }); + + it('that throws', async () => { + const result = await executeQuery(query, throwingData); + expect(result).to.containSubset({ + data, + errors: [ + { + message: syncError.message, + locations: [{ line: 4, column: 11 }], }, - }, - promiseNest: { - sync: null, - promise: null, - syncNest: { - sync: null, - promise: null, + { + message: syncError.message, + locations: [{ line: 6, column: 22 }], }, - promiseNest: { - sync: null, - promise: null, + { + message: syncError.message, + locations: [{ line: 7, column: 25 }], }, - }, - }, - }, - { - errors: [ - { - message: syncError.message, - locations: [{ line: 4, column: 11 }], - }, - { - message: syncError.message, - locations: [{ line: 7, column: 13 }], - }, - { - message: syncError.message, - locations: [{ line: 11, column: 13 }], - }, - { - message: syncError.message, - locations: [{ line: 16, column: 11 }], - }, - { - message: syncError.message, - locations: [{ line: 19, column: 13 }], - }, - { - message: syncError.message, - locations: [{ line: 23, column: 13 }], - }, - { - message: promiseError.message, - locations: [{ line: 5, column: 11 }], - }, - { - message: promiseError.message, - locations: [{ line: 8, column: 13 }], - }, - { - message: promiseError.message, - locations: [{ line: 12, column: 13 }], - }, - { - message: promiseError.message, - locations: [{ line: 17, column: 11 }], - }, - { - message: promiseError.message, - locations: [{ line: 20, column: 13 }], - }, - { - message: promiseError.message, - locations: [{ line: 24, column: 13 }], - }, - ], - }, - ); + { + message: syncError.message, + locations: [{ line: 10, column: 11 }], + }, + { + message: syncError.message, + locations: [{ line: 12, column: 22 }], + }, + { + message: syncError.message, + locations: [{ line: 13, column: 25 }], + }, + { + message: promiseError.message, + locations: [{ line: 5, column: 11 }], + }, + { + message: promiseError.message, + locations: [{ line: 6, column: 27 }], + }, + { + message: promiseError.message, + locations: [{ line: 7, column: 30 }], + }, + { + message: promiseError.message, + locations: [{ line: 11, column: 11 }], + }, + { + message: promiseError.message, + locations: [{ line: 12, column: 27 }], + }, + { + message: promiseError.message, + locations: [{ line: 13, column: 30 }], + }, + ], + }); + }); + }); - check( - 'nulls the first nullable object after a field in a long chain of non-null fields', - true, - ` - query Q { + describe('nulls the first nullable object after a field in a long chain of non-null fields', () => { + const query = ` + { syncNest { syncNonNullNest { promiseNonNullNest { @@ -404,84 +375,103 @@ describe('Execute: handles non-nullable types', () => { } } } - `, - { - data: { - syncNest: null, - promiseNest: null, - anotherNest: null, - anotherPromiseNest: null, - }, - errors: [ - { - message: - 'Cannot return null for non-nullable field DataType.syncNonNull.', - locations: [{ line: 8, column: 19 }], - }, - { - message: - 'Cannot return null for non-nullable field DataType.syncNonNull.', - locations: [{ line: 19, column: 19 }], - }, - { - message: - 'Cannot return null for non-nullable field DataType.promiseNonNull.', - locations: [{ line: 30, column: 19 }], - }, - { - message: - 'Cannot return null for non-nullable field DataType.promiseNonNull.', - locations: [{ line: 41, column: 19 }], - }, - ], - }, - { - errors: [ - { - message: syncNonNullError.message, - locations: [{ line: 8, column: 19 }], - }, - { - message: syncNonNullError.message, - locations: [{ line: 19, column: 19 }], - }, - { - message: promiseNonNullError.message, - locations: [{ line: 30, column: 19 }], - }, - { - message: promiseNonNullError.message, - locations: [{ line: 41, column: 19 }], - }, - ], - }, - ); + `; + const data = { + syncNest: null, + promiseNest: null, + anotherNest: null, + anotherPromiseNest: null, + }; + + it('that returns null', async () => { + const result = await executeQuery(query, nullingData); + expect(result).to.containSubset({ + data, + errors: [ + { + message: + 'Cannot return null for non-nullable field DataType.syncNonNull.', + locations: [{ line: 8, column: 19 }], + }, + { + message: + 'Cannot return null for non-nullable field DataType.syncNonNull.', + locations: [{ line: 19, column: 19 }], + }, + { + message: + 'Cannot return null for non-nullable field DataType.promiseNonNull.', + locations: [{ line: 30, column: 19 }], + }, + { + message: + 'Cannot return null for non-nullable field DataType.promiseNonNull.', + locations: [{ line: 41, column: 19 }], + }, + ], + }); + }); - check( - 'nulls the top level if non-nullable field', - false, - ` - query Q { syncNonNull } - `, - { - data: null, - errors: [ - { - message: - 'Cannot return null for non-nullable field DataType.syncNonNull.', - locations: [{ line: 2, column: 17 }], - }, - ], - }, - { - errors: [ - { - message: syncNonNullError.message, - locations: [{ line: 2, column: 17 }], - }, - ], - }, - ); + it('that throws', async () => { + const result = await executeQuery(query, throwingData); + expect(result).to.containSubset({ + data, + errors: [ + { + message: syncNonNullError.message, + locations: [{ line: 8, column: 19 }], + }, + { + message: syncNonNullError.message, + locations: [{ line: 19, column: 19 }], + }, + { + message: promiseNonNullError.message, + locations: [{ line: 30, column: 19 }], + }, + { + message: promiseNonNullError.message, + locations: [{ line: 41, column: 19 }], + }, + ], + }); + }); + }); + + describe('nulls the top level if non-nullable field', () => { + const query = ` + { + syncNonNull + } + `; + + it('that returns null', async () => { + const result = await executeSyncAndAsync(query, nullingData); + expect(result).to.containSubset({ + data: null, + errors: [ + { + message: + 'Cannot return null for non-nullable field DataType.syncNonNull.', + locations: [{ line: 3, column: 9 }], + }, + ], + }); + }); + + it('that throws', async () => { + const result = await executeSyncAndAsync(query, throwingData); + expect(result).to.containSubset({ + data: null, + errors: [ + { + message: syncNonNullError.message, + locations: [{ line: 3, column: 9 }], + }, + ], + }); + }); + }); describe('Handles non-null argument', () => { const schemaWithNonNullArg = new GraphQLSchema({ From 82237dbf9a517d621bff33db7df7c75f801e9cb7 Mon Sep 17 00:00:00 2001 From: Ivan Goncharov Date: Mon, 9 Apr 2018 19:19:24 +0300 Subject: [PATCH 3/5] containSubset => deep.equal --- src/execution/__tests__/nonnull-test.js | 107 +++++++++++++++++++++--- 1 file changed, 95 insertions(+), 12 deletions(-) diff --git a/src/execution/__tests__/nonnull-test.js b/src/execution/__tests__/nonnull-test.js index f0c35c5203..4382b92adf 100644 --- a/src/execution/__tests__/nonnull-test.js +++ b/src/execution/__tests__/nonnull-test.js @@ -139,18 +139,19 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeSyncAndAsync(query, nullingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { sync: null }, }); }); it('that throws', async () => { const result = await executeSyncAndAsync(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { sync: null }, errors: [ { message: syncError.message, + path: ['sync'], locations: [{ line: 3, column: 9 }], }, ], @@ -169,12 +170,13 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeSyncAndAsync(query, nullingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { syncNest: null }, errors: [ { message: 'Cannot return null for non-nullable field DataType.syncNonNull.', + path: ['syncNest', 'syncNonNull'], locations: [{ line: 4, column: 11 }], }, ], @@ -183,11 +185,12 @@ describe('Execute: handles non-nullable types', () => { it('that throws', async () => { const result = await executeSyncAndAsync(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { syncNest: null }, errors: [ { message: syncNonNullError.message, + path: ['syncNest', 'syncNonNull'], locations: [{ line: 4, column: 11 }], }, ], @@ -206,12 +209,13 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeSyncAndAsync(query, nullingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { promiseNest: null }, errors: [ { message: 'Cannot return null for non-nullable field DataType.syncNonNull.', + path: ['promiseNest', 'syncNonNull'], locations: [{ line: 4, column: 11 }], }, ], @@ -220,11 +224,12 @@ describe('Execute: handles non-nullable types', () => { it('that throws', async () => { const result = await executeSyncAndAsync(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: { promiseNest: null }, errors: [ { message: syncNonNullError.message, + path: ['promiseNest', 'syncNonNull'], locations: [{ line: 4, column: 11 }], }, ], @@ -266,60 +271,72 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeQuery(query, nullingData); - expect(result).to.containSubset({ data }); + expect(result).to.deep.equal({ data }); }); it('that throws', async () => { const result = await executeQuery(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data, errors: [ { message: syncError.message, + path: ['syncNest', 'sync'], locations: [{ line: 4, column: 11 }], }, { message: syncError.message, + path: ['syncNest', 'syncNest', 'sync'], locations: [{ line: 6, column: 22 }], }, { message: syncError.message, + path: ['syncNest', 'promiseNest', 'sync'], locations: [{ line: 7, column: 25 }], }, { message: syncError.message, + path: ['promiseNest', 'sync'], locations: [{ line: 10, column: 11 }], }, { message: syncError.message, + path: ['promiseNest', 'syncNest', 'sync'], locations: [{ line: 12, column: 22 }], }, { message: syncError.message, + path: ['promiseNest', 'promiseNest', 'sync'], locations: [{ line: 13, column: 25 }], }, { message: promiseError.message, + path: ['syncNest', 'promise'], locations: [{ line: 5, column: 11 }], }, { message: promiseError.message, + path: ['syncNest', 'syncNest', 'promise'], locations: [{ line: 6, column: 27 }], }, { message: promiseError.message, + path: ['syncNest', 'promiseNest', 'promise'], locations: [{ line: 7, column: 30 }], }, { message: promiseError.message, + path: ['promiseNest', 'promise'], locations: [{ line: 11, column: 11 }], }, { message: promiseError.message, + path: ['promiseNest', 'syncNest', 'promise'], locations: [{ line: 12, column: 27 }], }, { message: promiseError.message, + path: ['promiseNest', 'promiseNest', 'promise'], locations: [{ line: 13, column: 30 }], }, ], @@ -385,27 +402,59 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeQuery(query, nullingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data, errors: [ { message: 'Cannot return null for non-nullable field DataType.syncNonNull.', + path: [ + 'syncNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNull', + ], locations: [{ line: 8, column: 19 }], }, { message: 'Cannot return null for non-nullable field DataType.syncNonNull.', + path: [ + 'promiseNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNull', + ], locations: [{ line: 19, column: 19 }], }, { message: 'Cannot return null for non-nullable field DataType.promiseNonNull.', + path: [ + 'anotherNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'promiseNonNull', + ], locations: [{ line: 30, column: 19 }], }, { message: 'Cannot return null for non-nullable field DataType.promiseNonNull.', + path: [ + 'anotherPromiseNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'promiseNonNull', + ], locations: [{ line: 41, column: 19 }], }, ], @@ -414,23 +463,55 @@ describe('Execute: handles non-nullable types', () => { it('that throws', async () => { const result = await executeQuery(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data, errors: [ { message: syncNonNullError.message, + path: [ + 'syncNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNull', + ], locations: [{ line: 8, column: 19 }], }, { message: syncNonNullError.message, + path: [ + 'promiseNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNull', + ], locations: [{ line: 19, column: 19 }], }, { message: promiseNonNullError.message, + path: [ + 'anotherNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'promiseNonNull', + ], locations: [{ line: 30, column: 19 }], }, { message: promiseNonNullError.message, + path: [ + 'anotherPromiseNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'syncNonNullNest', + 'promiseNonNullNest', + 'promiseNonNull', + ], locations: [{ line: 41, column: 19 }], }, ], @@ -447,12 +528,13 @@ describe('Execute: handles non-nullable types', () => { it('that returns null', async () => { const result = await executeSyncAndAsync(query, nullingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: null, errors: [ { message: 'Cannot return null for non-nullable field DataType.syncNonNull.', + path: ['syncNonNull'], locations: [{ line: 3, column: 9 }], }, ], @@ -461,11 +543,12 @@ describe('Execute: handles non-nullable types', () => { it('that throws', async () => { const result = await executeSyncAndAsync(query, throwingData); - expect(result).to.containSubset({ + expect(result).to.deep.equal({ data: null, errors: [ { message: syncNonNullError.message, + path: ['syncNonNull'], locations: [{ line: 3, column: 9 }], }, ], From f75ff2fe3530ee96f1b5d3057ff801caf976b55a Mon Sep 17 00:00:00 2001 From: Ivan Goncharov Date: Thu, 19 Apr 2018 02:34:30 +0300 Subject: [PATCH 4/5] Change order of errors because of #1286 --- src/execution/__tests__/nonnull-test.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/execution/__tests__/nonnull-test.js b/src/execution/__tests__/nonnull-test.js index 4382b92adf..1cb2c240d3 100644 --- a/src/execution/__tests__/nonnull-test.js +++ b/src/execution/__tests__/nonnull-test.js @@ -304,11 +304,6 @@ describe('Execute: handles non-nullable types', () => { path: ['promiseNest', 'syncNest', 'sync'], locations: [{ line: 12, column: 22 }], }, - { - message: syncError.message, - path: ['promiseNest', 'promiseNest', 'sync'], - locations: [{ line: 13, column: 25 }], - }, { message: promiseError.message, path: ['syncNest', 'promise'], @@ -319,6 +314,11 @@ describe('Execute: handles non-nullable types', () => { path: ['syncNest', 'syncNest', 'promise'], locations: [{ line: 6, column: 27 }], }, + { + message: syncError.message, + path: ['promiseNest', 'promiseNest', 'sync'], + locations: [{ line: 13, column: 25 }], + }, { message: promiseError.message, path: ['syncNest', 'promiseNest', 'promise'], From 21bb901537826386a51d79c6617433ba926ee326 Mon Sep 17 00:00:00 2001 From: Ivan Goncharov Date: Thu, 19 Apr 2018 02:39:39 +0300 Subject: [PATCH 5/5] remove excessive async/await --- src/execution/__tests__/nonnull-test.js | 30 ++++++++++++------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/execution/__tests__/nonnull-test.js b/src/execution/__tests__/nonnull-test.js index 1cb2c240d3..8222839096 100644 --- a/src/execution/__tests__/nonnull-test.js +++ b/src/execution/__tests__/nonnull-test.js @@ -568,7 +568,7 @@ describe('Execute: handles non-nullable types', () => { type: GraphQLNonNull(GraphQLString), }, }, - resolve: async (_, args) => { + resolve: (_, args) => { if (typeof args.cannotBeNull === 'string') { return 'Passed: ' + args.cannotBeNull; } @@ -578,8 +578,8 @@ describe('Execute: handles non-nullable types', () => { }), }); - it('succeeds when passed non-null literal value', async () => { - const result = await execute({ + it('succeeds when passed non-null literal value', () => { + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query { @@ -595,8 +595,8 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('succeeds when passed non-null variable value', async () => { - const result = await execute({ + it('succeeds when passed non-null variable value', () => { + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query ($testVar: String!) { @@ -615,8 +615,8 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('succeeds when missing variable has default value', async () => { - const result = await execute({ + it('succeeds when missing variable has default value', () => { + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query ($testVar: String = "default value") { @@ -635,10 +635,10 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('field error when missing non-null arg', async () => { + it('field error when missing non-null arg', () => { // Note: validation should identify this issue first (missing args rule) // however execution should still protect against this. - const result = await execute({ + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query { @@ -662,10 +662,10 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('field error when non-null arg provided null', async () => { + it('field error when non-null arg provided null', () => { // Note: validation should identify this issue first (values of correct // type rule) however execution should still protect against this. - const result = await execute({ + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query { @@ -690,10 +690,10 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('field error when non-null arg not provided variable value', async () => { + it('field error when non-null arg not provided variable value', () => { // Note: validation should identify this issue first (variables in allowed // position rule) however execution should still protect against this. - const result = await execute({ + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query ($testVar: String) { @@ -722,8 +722,8 @@ describe('Execute: handles non-nullable types', () => { }); }); - it('field error when non-null arg provided variable with explicit null value', async () => { - const result = await execute({ + it('field error when non-null arg provided variable with explicit null value', () => { + const result = execute({ schema: schemaWithNonNullArg, document: parse(` query ($testVar: String = "default value") {