graphql-tag 2.10.0 → 2.10.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/test/graphql.js CHANGED
@@ -1,465 +1,461 @@
1
- const gqlRequire = require('../src');
2
- const gqlDefault = require('../src').default;
1
+ const gql = require('../src');
3
2
  const loader = require('../loader');
4
3
  const assert = require('chai').assert;
5
4
 
6
- [gqlRequire, gqlDefault].forEach((gql, i) => {
7
- describe(`gql ${i}`, () => {
8
- it('parses queries', () => {
9
- assert.equal(gql`{ testQuery }`.kind, 'Document');
10
- });
5
+ describe('gql', () => {
6
+ it('parses queries', () => {
7
+ assert.equal(gql`{ testQuery }`.kind, 'Document');
8
+ });
11
9
 
12
- it('parses queries when called as a function', () => {
13
- assert.equal(gql('{ testQuery }').kind, 'Document');
14
- });
10
+ it('parses queries when called as a function', () => {
11
+ assert.equal(gql('{ testQuery }').kind, 'Document');
12
+ });
15
13
 
16
- it('parses queries with weird substitutions', () => {
17
- const obj = {};
18
- assert.equal(gql`{ field(input: "${obj.missing}") }`.kind, 'Document');
19
- assert.equal(gql`{ field(input: "${null}") }`.kind, 'Document');
20
- assert.equal(gql`{ field(input: "${0}") }`.kind, 'Document');
21
- });
14
+ it('parses queries with weird substitutions', () => {
15
+ const obj = {};
16
+ assert.equal(gql`{ field(input: "${obj.missing}") }`.kind, 'Document');
17
+ assert.equal(gql`{ field(input: "${null}") }`.kind, 'Document');
18
+ assert.equal(gql`{ field(input: "${0}") }`.kind, 'Document');
19
+ });
22
20
 
23
- it('allows interpolation of documents generated by the webpack loader', () => {
24
- const sameFragment = "fragment SomeFragmentName on SomeType { someField }";
21
+ it('allows interpolation of documents generated by the webpack loader', () => {
22
+ const sameFragment = "fragment SomeFragmentName on SomeType { someField }";
23
+
24
+ const jsSource = loader.call(
25
+ { cacheable() {} },
26
+ "fragment SomeFragmentName on SomeType { someField }"
27
+ );
28
+ const module = { exports: undefined };
29
+ eval(jsSource);
30
+
31
+ const document = gql`query { ...SomeFragmentName } ${module.exports}`;
32
+ assert.equal(document.kind, 'Document');
33
+ assert.equal(document.definitions.length, 2);
34
+ assert.equal(document.definitions[0].kind, 'OperationDefinition');
35
+ assert.equal(document.definitions[1].kind, 'FragmentDefinition');
36
+ });
25
37
 
26
- const jsSource = loader.call(
27
- { cacheable() {} },
28
- "fragment SomeFragmentName on SomeType { someField }"
29
- );
30
- const module = { exports: undefined };
31
- eval(jsSource);
38
+ it('parses queries through webpack loader', () => {
39
+ const jsSource = loader.call({ cacheable() {} }, '{ testQuery }');
40
+ const module = { exports: undefined };
41
+ eval(jsSource);
42
+ assert.equal(module.exports.kind, 'Document');
43
+ });
32
44
 
33
- const document = gql`query { ...SomeFragmentName } ${module.exports}`;
34
- assert.equal(document.kind, 'Document');
35
- assert.equal(document.definitions.length, 2);
36
- assert.equal(document.definitions[0].kind, 'OperationDefinition');
37
- assert.equal(document.definitions[1].kind, 'FragmentDefinition');
38
- });
45
+ it('parses single query through webpack loader', () => {
46
+ const jsSource = loader.call({ cacheable() {} }, `
47
+ query Q1 { testQuery }
48
+ `);
49
+ const module = { exports: undefined };
50
+ eval(jsSource);
51
+
52
+ assert.equal(module.exports.kind, 'Document');
53
+ assert.exists(module.exports.Q1);
54
+ assert.equal(module.exports.Q1.kind, 'Document');
55
+ assert.equal(module.exports.Q1.definitions.length, 1);
56
+ });
39
57
 
40
- it('parses queries through webpack loader', () => {
41
- const jsSource = loader.call({ cacheable() {} }, '{ testQuery }');
42
- const module = { exports: undefined };
43
- eval(jsSource);
44
- assert.equal(module.exports.kind, 'Document');
45
- });
58
+ it('parses single query and exports as default', () => {
59
+ const jsSource = loader.call({ cacheable() {} }, `
60
+ query Q1 { testQuery }
61
+ `);
62
+ const module = { exports: undefined };
63
+ eval(jsSource);
46
64
 
47
- it('parses single query through webpack loader', () => {
48
- const jsSource = loader.call({ cacheable() {} }, `
49
- query Q1 { testQuery }
50
- `);
51
- const module = { exports: undefined };
52
- eval(jsSource);
65
+ assert.deepEqual(module.exports.definitions, module.exports.Q1.definitions);
66
+ });
53
67
 
54
- assert.equal(module.exports.kind, 'Document');
55
- assert.exists(module.exports.Q1);
56
- assert.equal(module.exports.Q1.kind, 'Document');
57
- assert.equal(module.exports.Q1.definitions.length, 1);
58
- });
68
+ it('parses multiple queries through webpack loader', () => {
69
+ const jsSource = loader.call({ cacheable() {} }, `
70
+ query Q1 { testQuery }
71
+ query Q2 { testQuery2 }
72
+ `);
73
+ const module = { exports: undefined };
74
+ eval(jsSource);
75
+
76
+ assert.exists(module.exports.Q1);
77
+ assert.exists(module.exports.Q2);
78
+ assert.equal(module.exports.Q1.kind, 'Document');
79
+ assert.equal(module.exports.Q2.kind, 'Document');
80
+ assert.equal(module.exports.Q1.definitions.length, 1);
81
+ assert.equal(module.exports.Q2.definitions.length, 1);
82
+ });
59
83
 
60
- it('parses single query and exports as default', () => {
61
- const jsSource = loader.call({ cacheable() {} }, `
62
- query Q1 { testQuery }
63
- `);
64
- const module = { exports: undefined };
65
- eval(jsSource);
84
+ it('parses fragments with variable definitions', () => {
85
+ gql.enableExperimentalFragmentVariables();
66
86
 
67
- assert.deepEqual(module.exports.definitions, module.exports.Q1.definitions);
68
- });
87
+ const parsed = gql`fragment A ($arg: String!) on Type { testQuery }`;
88
+ assert.equal(parsed.kind, 'Document');
89
+ assert.exists(parsed.definitions[0].variableDefinitions);
69
90
 
70
- it('parses multiple queries through webpack loader', () => {
71
- const jsSource = loader.call({ cacheable() {} }, `
72
- query Q1 { testQuery }
73
- query Q2 { testQuery2 }
74
- `);
75
- const module = { exports: undefined };
76
- eval(jsSource);
77
-
78
- assert.exists(module.exports.Q1);
79
- assert.exists(module.exports.Q2);
80
- assert.equal(module.exports.Q1.kind, 'Document');
81
- assert.equal(module.exports.Q2.kind, 'Document');
82
- assert.equal(module.exports.Q1.definitions.length, 1);
83
- assert.equal(module.exports.Q2.definitions.length, 1);
84
- });
91
+ gql.disableExperimentalFragmentVariables()
92
+ });
85
93
 
86
- it('parses fragments with variable definitions', () => {
87
- gql.enableExperimentalFragmentVariables();
94
+ // see https://github.com/apollographql/graphql-tag/issues/168
95
+ it('does not nest queries needlessly in named exports', () => {
96
+ const jsSource = loader.call({ cacheable() {} }, `
97
+ query Q1 { testQuery }
98
+ query Q2 { testQuery2 }
99
+ query Q3 { test Query3 }
100
+ `);
101
+ const module = { exports: undefined };
102
+ eval(jsSource);
103
+
104
+ assert.notExists(module.exports.Q2.Q1);
105
+ assert.notExists(module.exports.Q3.Q1);
106
+ assert.notExists(module.exports.Q3.Q2);
107
+ });
88
108
 
89
- const parsed = gql`fragment A ($arg: String!) on Type { testQuery }`;
90
- assert.equal(parsed.kind, 'Document');
91
- assert.exists(parsed.definitions[0].variableDefinitions);
109
+ it('tracks fragment dependencies from multiple queries through webpack loader', () => {
110
+ const jsSource = loader.call({ cacheable() {} }, `
111
+ fragment F1 on F { testQuery }
112
+ fragment F2 on F { testQuery2 }
113
+ fragment F3 on F { testQuery3 }
114
+ query Q1 { ...F1 }
115
+ query Q2 { ...F2 }
116
+ query Q3 {
117
+ ...F1
118
+ ...F2
119
+ }
120
+ `);
121
+ const module = { exports: undefined };
122
+ eval(jsSource);
123
+
124
+ assert.exists(module.exports.Q1);
125
+ assert.exists(module.exports.Q2);
126
+ assert.exists(module.exports.Q3);
127
+ const Q1 = module.exports.Q1.definitions;
128
+ const Q2 = module.exports.Q2.definitions;
129
+ const Q3 = module.exports.Q3.definitions;
130
+
131
+ assert.equal(Q1.length, 2);
132
+ assert.equal(Q1[0].name.value, 'Q1');
133
+ assert.equal(Q1[1].name.value, 'F1');
134
+
135
+ assert.equal(Q2.length, 2);
136
+ assert.equal(Q2[0].name.value, 'Q2');
137
+ assert.equal(Q2[1].name.value, 'F2');
138
+
139
+ assert.equal(Q3.length, 3);
140
+ assert.equal(Q3[0].name.value, 'Q3');
141
+ assert.equal(Q3[1].name.value, 'F1');
142
+ assert.equal(Q3[2].name.value, 'F2');
92
143
 
93
- gql.disableExperimentalFragmentVariables()
94
- });
95
-
96
- // see https://github.com/apollographql/graphql-tag/issues/168
97
- it('does not nest queries needlessly in named exports', () => {
98
- const jsSource = loader.call({ cacheable() {} }, `
99
- query Q1 { testQuery }
100
- query Q2 { testQuery2 }
101
- query Q3 { test Query3 }
102
- `);
103
- const module = { exports: undefined };
104
- eval(jsSource);
144
+ });
105
145
 
106
- assert.notExists(module.exports.Q2.Q1);
107
- assert.notExists(module.exports.Q3.Q1);
108
- assert.notExists(module.exports.Q3.Q2);
109
- });
146
+ it('tracks fragment dependencies across nested fragments', () => {
147
+ const jsSource = loader.call({ cacheable() {} }, `
148
+ fragment F11 on F { testQuery }
149
+ fragment F22 on F {
150
+ ...F11
151
+ testQuery2
152
+ }
153
+ fragment F33 on F {
154
+ ...F22
155
+ testQuery3
156
+ }
157
+
158
+ query Q1 {
159
+ ...F33
160
+ }
161
+
162
+ query Q2 {
163
+ id
164
+ }
165
+ `);
166
+
167
+ const module = { exports: undefined };
168
+ eval(jsSource);
169
+
170
+ assert.exists(module.exports.Q1);
171
+ assert.exists(module.exports.Q2);
172
+
173
+ const Q1 = module.exports.Q1.definitions;
174
+ const Q2 = module.exports.Q2.definitions;
175
+
176
+ assert.equal(Q1.length, 4);
177
+ assert.equal(Q1[0].name.value, 'Q1');
178
+ assert.equal(Q1[1].name.value, 'F33');
179
+ assert.equal(Q1[2].name.value, 'F22');
180
+ assert.equal(Q1[3].name.value, 'F11');
181
+
182
+ assert.equal(Q2.length, 1);
183
+ });
110
184
 
111
- it('tracks fragment dependencies from multiple queries through webpack loader', () => {
112
- const jsSource = loader.call({ cacheable() {} }, `
113
- fragment F1 on F { testQuery }
114
- fragment F2 on F { testQuery2 }
115
- fragment F3 on F { testQuery3 }
116
- query Q1 { ...F1 }
117
- query Q2 { ...F2 }
118
- query Q3 {
119
- ...F1
120
- ...F2
185
+ it('correctly imports other files through the webpack loader', () => {
186
+ const query = `#import "./fragment_definition.graphql"
187
+ query {
188
+ author {
189
+ ...authorDetails
121
190
  }
122
- `);
123
- const module = { exports: undefined };
124
- eval(jsSource);
125
-
126
- assert.exists(module.exports.Q1);
127
- assert.exists(module.exports.Q2);
128
- assert.exists(module.exports.Q3);
129
- const Q1 = module.exports.Q1.definitions;
130
- const Q2 = module.exports.Q2.definitions;
131
- const Q3 = module.exports.Q3.definitions;
132
-
133
- assert.equal(Q1.length, 2);
134
- assert.equal(Q1[0].name.value, 'Q1');
135
- assert.equal(Q1[1].name.value, 'F1');
136
-
137
- assert.equal(Q2.length, 2);
138
- assert.equal(Q2[0].name.value, 'Q2');
139
- assert.equal(Q2[1].name.value, 'F2');
140
-
141
- assert.equal(Q3.length, 3);
142
- assert.equal(Q3[0].name.value, 'Q3');
143
- assert.equal(Q3[1].name.value, 'F1');
144
- assert.equal(Q3[2].name.value, 'F2');
145
-
146
- });
191
+ }`;
192
+ const jsSource = loader.call({ cacheable() {} }, query);
193
+ const oldRequire = require;
194
+ const module = { exports: undefined };
195
+ const require = (path) => {
196
+ assert.equal(path, './fragment_definition.graphql');
197
+ return gql`
198
+ fragment authorDetails on Author {
199
+ firstName
200
+ lastName
201
+ }`;
202
+ };
203
+ eval(jsSource);
204
+ assert.equal(module.exports.kind, 'Document');
205
+ const definitions = module.exports.definitions;
206
+ assert.equal(definitions.length, 2);
207
+ assert.equal(definitions[0].kind, 'OperationDefinition');
208
+ assert.equal(definitions[1].kind, 'FragmentDefinition');
209
+ });
147
210
 
148
- it('tracks fragment dependencies across nested fragments', () => {
149
- const jsSource = loader.call({ cacheable() {} }, `
150
- fragment F11 on F { testQuery }
151
- fragment F22 on F {
152
- ...F11
153
- testQuery2
154
- }
155
- fragment F33 on F {
156
- ...F22
157
- testQuery3
158
- }
211
+ it('tracks fragment dependencies across fragments loaded via the webpack loader', () => {
212
+ const query = `#import "./fragment_definition.graphql"
213
+ fragment F111 on F {
214
+ ...F222
215
+ }
159
216
 
160
- query Q1 {
161
- ...F33
162
- }
217
+ query Q1 {
218
+ ...F111
219
+ }
163
220
 
164
- query Q2 {
165
- id
166
- }
167
- `);
168
-
169
- const module = { exports: undefined };
170
- eval(jsSource);
221
+ query Q2 {
222
+ a
223
+ }
224
+ `;
225
+ const jsSource = loader.call({ cacheable() {} }, query);
226
+ const oldRequire = require;
227
+ const module = { exports: undefined };
228
+ const require = (path) => {
229
+ assert.equal(path, './fragment_definition.graphql');
230
+ return gql`
231
+ fragment F222 on F {
232
+ f1
233
+ f2
234
+ }`;
235
+ };
236
+ eval(jsSource);
171
237
 
172
- assert.exists(module.exports.Q1);
173
- assert.exists(module.exports.Q2);
238
+ assert.exists(module.exports.Q1);
239
+ assert.exists(module.exports.Q2);
174
240
 
175
- const Q1 = module.exports.Q1.definitions;
176
- const Q2 = module.exports.Q2.definitions;
241
+ const Q1 = module.exports.Q1.definitions;
242
+ const Q2 = module.exports.Q2.definitions;
177
243
 
178
- assert.equal(Q1.length, 4);
179
- assert.equal(Q1[0].name.value, 'Q1');
180
- assert.equal(Q1[1].name.value, 'F33');
181
- assert.equal(Q1[2].name.value, 'F22');
182
- assert.equal(Q1[3].name.value, 'F11');
244
+ assert.equal(Q1.length, 3);
245
+ assert.equal(Q1[0].name.value, 'Q1');
246
+ assert.equal(Q1[1].name.value, 'F111');
247
+ assert.equal(Q1[2].name.value, 'F222');
183
248
 
184
- assert.equal(Q2.length, 1);
185
- });
249
+ assert.equal(Q2.length, 1);
250
+ });
186
251
 
187
- it('correctly imports other files through the webpack loader', () => {
188
- const query = `#import "./fragment_definition.graphql"
252
+ it('does not complain when presented with normal comments', (done) => {
253
+ assert.doesNotThrow(() => {
254
+ const query = `#normal comment
189
255
  query {
190
256
  author {
191
257
  ...authorDetails
192
258
  }
193
259
  }`;
194
260
  const jsSource = loader.call({ cacheable() {} }, query);
195
- const oldRequire = require;
196
261
  const module = { exports: undefined };
197
- const require = (path) => {
198
- assert.equal(path, './fragment_definition.graphql');
199
- return gql`
200
- fragment authorDetails on Author {
201
- firstName
202
- lastName
203
- }`;
204
- };
205
262
  eval(jsSource);
206
263
  assert.equal(module.exports.kind, 'Document');
207
- const definitions = module.exports.definitions;
208
- assert.equal(definitions.length, 2);
209
- assert.equal(definitions[0].kind, 'OperationDefinition');
210
- assert.equal(definitions[1].kind, 'FragmentDefinition');
264
+ done();
211
265
  });
266
+ });
212
267
 
213
- it('tracks fragment dependencies across fragments loaded via the webpack loader', () => {
214
- const query = `#import "./fragment_definition.graphql"
215
- fragment F111 on F {
216
- ...F222
217
- }
268
+ it('returns the same object for the same query', () => {
269
+ assert.isTrue(gql`{ sameQuery }` === gql`{ sameQuery }`);
270
+ });
218
271
 
219
- query Q1 {
220
- ...F111
221
- }
272
+ it('returns the same object for the same query, even with whitespace differences', () => {
273
+ assert.isTrue(gql`{ sameQuery }` === gql` { sameQuery, }`);
274
+ });
222
275
 
223
- query Q2 {
224
- a
225
- }
226
- `;
227
- const jsSource = loader.call({ cacheable() {} }, query);
228
- const oldRequire = require;
229
- const module = { exports: undefined };
230
- const require = (path) => {
231
- assert.equal(path, './fragment_definition.graphql');
232
- return gql`
233
- fragment F222 on F {
234
- f1
235
- f2
236
- }`;
237
- };
238
- eval(jsSource);
276
+ const fragmentAst = gql`
277
+ fragment UserFragment on User {
278
+ firstName
279
+ lastName
280
+ }
281
+ `;
239
282
 
240
- assert.exists(module.exports.Q1);
241
- assert.exists(module.exports.Q2);
283
+ it('returns the same object for the same fragment', () => {
284
+ assert.isTrue(gql`fragment same on Same { sameQuery }` ===
285
+ gql`fragment same on Same { sameQuery }`);
286
+ });
242
287
 
243
- const Q1 = module.exports.Q1.definitions;
244
- const Q2 = module.exports.Q2.definitions;
288
+ it('returns the same object for the same document with substitution', () => {
289
+ // We know that calling `gql` on a fragment string will always return
290
+ // the same document, so we can reuse `fragmentAst`
291
+ assert.isTrue(gql`{ ...UserFragment } ${fragmentAst}` ===
292
+ gql`{ ...UserFragment } ${fragmentAst}`);
293
+ });
245
294
 
246
- assert.equal(Q1.length, 3);
247
- assert.equal(Q1[0].name.value, 'Q1');
248
- assert.equal(Q1[1].name.value, 'F111');
249
- assert.equal(Q1[2].name.value, 'F222');
295
+ it('can reference a fragment that references as fragment', () => {
296
+ const secondFragmentAst = gql`
297
+ fragment SecondUserFragment on User {
298
+ ...UserFragment
299
+ }
300
+ ${fragmentAst}
301
+ `;
302
+
303
+ const ast = gql`
304
+ {
305
+ user(id: 5) {
306
+ ...SecondUserFragment
307
+ }
308
+ }
309
+ ${secondFragmentAst}
310
+ `;
311
+
312
+ assert.deepEqual(ast, gql`
313
+ {
314
+ user(id: 5) {
315
+ ...SecondUserFragment
316
+ }
317
+ }
318
+ fragment SecondUserFragment on User {
319
+ ...UserFragment
320
+ }
321
+ fragment UserFragment on User {
322
+ firstName
323
+ lastName
324
+ }
325
+ `);
326
+ });
250
327
 
251
- assert.equal(Q2.length, 1);
328
+ describe('fragment warnings', () => {
329
+ let warnings = [];
330
+ const oldConsoleWarn = console.warn;
331
+ beforeEach(() => {
332
+ gql.resetCaches();
333
+ warnings = [];
334
+ console.warn = (w) => warnings.push(w);
252
335
  });
253
-
254
- it('does not complain when presented with normal comments', (done) => {
255
- assert.doesNotThrow(() => {
256
- const query = `#normal comment
257
- query {
258
- author {
259
- ...authorDetails
260
- }
261
- }`;
262
- const jsSource = loader.call({ cacheable() {} }, query);
263
- const module = { exports: undefined };
264
- eval(jsSource);
265
- assert.equal(module.exports.kind, 'Document');
266
- done();
267
- });
336
+ afterEach(() => {
337
+ console.warn = oldConsoleWarn;
268
338
  });
269
339
 
270
- it('returns the same object for the same query', () => {
271
- assert.isTrue(gql`{ sameQuery }` === gql`{ sameQuery }`);
272
- });
340
+ it('warns if you use the same fragment name for different fragments', () => {
341
+ const frag1 = gql`fragment TestSame on Bar { fieldOne }`;
342
+ const frag2 = gql`fragment TestSame on Bar { fieldTwo }`;
273
343
 
274
- it('returns the same object for the same query, even with whitespace differences', () => {
275
- assert.isTrue(gql`{ sameQuery }` === gql` { sameQuery, }`);
344
+ assert.isFalse(frag1 === frag2);
345
+ assert.equal(warnings.length, 1);
276
346
  });
277
347
 
278
- const fragmentAst = gql`
279
- fragment UserFragment on User {
280
- firstName
281
- lastName
282
- }
283
- `;
348
+ it('does not warn if you use the same fragment name for the same fragment', () => {
349
+ const frag1 = gql`fragment TestDifferent on Bar { fieldOne }`;
350
+ const frag2 = gql`fragment TestDifferent on Bar { fieldOne }`;
284
351
 
285
- it('returns the same object for the same fragment', () => {
286
- assert.isTrue(gql`fragment same on Same { sameQuery }` ===
287
- gql`fragment same on Same { sameQuery }`);
352
+ assert.isTrue(frag1 === frag2);
353
+ assert.equal(warnings.length, 0);
288
354
  });
289
355
 
290
- it('returns the same object for the same document with substitution', () => {
291
- // We know that calling `gql` on a fragment string will always return
292
- // the same document, so we can reuse `fragmentAst`
293
- assert.isTrue(gql`{ ...UserFragment } ${fragmentAst}` ===
294
- gql`{ ...UserFragment } ${fragmentAst}`);
356
+ it('does not warn if you use the same embedded fragment in two different queries', () => {
357
+ const frag1 = gql`fragment TestEmbedded on Bar { field }`;
358
+ const query1 = gql`{ bar { fieldOne ...TestEmbedded } } ${frag1}`;
359
+ const query2 = gql`{ bar { fieldTwo ...TestEmbedded } } ${frag1}`;
360
+
361
+ assert.isFalse(query1 === query2);
362
+ assert.equal(warnings.length, 0);
295
363
  });
296
364
 
297
- it('can reference a fragment that references as fragment', () => {
298
- const secondFragmentAst = gql`
299
- fragment SecondUserFragment on User {
300
- ...UserFragment
301
- }
302
- ${fragmentAst}
303
- `;
365
+ it('does not warn if you use the same fragment name for embedded and non-embedded fragments', () => {
366
+ const frag1 = gql`fragment TestEmbeddedTwo on Bar { field }`;
367
+ const query1 = gql`{ bar { ...TestEmbedded } } ${frag1}`;
368
+ const query2 = gql`{ bar { ...TestEmbedded } } fragment TestEmbeddedTwo on Bar { field }`;
304
369
 
305
- const ast = gql`
306
- {
307
- user(id: 5) {
308
- ...SecondUserFragment
309
- }
310
- }
311
- ${secondFragmentAst}
312
- `;
313
-
314
- assert.deepEqual(ast, gql`
315
- {
316
- user(id: 5) {
317
- ...SecondUserFragment
318
- }
319
- }
320
- fragment SecondUserFragment on User {
321
- ...UserFragment
322
- }
323
- fragment UserFragment on User {
324
- firstName
325
- lastName
326
- }
327
- `);
370
+ assert.equal(warnings.length, 0);
328
371
  });
372
+ });
329
373
 
330
- describe('fragment warnings', () => {
331
- let warnings = [];
332
- const oldConsoleWarn = console.warn;
333
- beforeEach(() => {
334
- gqlRequire.resetCaches();
335
- warnings = [];
336
- console.warn = (w) => warnings.push(w);
337
- });
338
- afterEach(() => {
339
- console.warn = oldConsoleWarn;
340
- });
341
-
342
- it('warns if you use the same fragment name for different fragments', () => {
343
- const frag1 = gql`fragment TestSame on Bar { fieldOne }`;
344
- const frag2 = gql`fragment TestSame on Bar { fieldTwo }`;
345
-
346
- assert.isFalse(frag1 === frag2);
347
- assert.equal(warnings.length, 1);
348
- });
349
-
350
- it('does not warn if you use the same fragment name for the same fragment', () => {
351
- const frag1 = gql`fragment TestDifferent on Bar { fieldOne }`;
352
- const frag2 = gql`fragment TestDifferent on Bar { fieldOne }`;
353
-
354
- assert.isTrue(frag1 === frag2);
355
- assert.equal(warnings.length, 0);
356
- });
357
-
358
- it('does not warn if you use the same embedded fragment in two different queries', () => {
359
- const frag1 = gql`fragment TestEmbedded on Bar { field }`;
360
- const query1 = gql`{ bar { fieldOne ...TestEmbedded } } ${frag1}`;
361
- const query2 = gql`{ bar { fieldTwo ...TestEmbedded } } ${frag1}`;
362
-
363
- assert.isFalse(query1 === query2);
364
- assert.equal(warnings.length, 0);
365
- });
366
-
367
- it('does not warn if you use the same fragment name for embedded and non-embedded fragments', () => {
368
- const frag1 = gql`fragment TestEmbeddedTwo on Bar { field }`;
369
- const query1 = gql`{ bar { ...TestEmbedded } } ${frag1}`;
370
- const query2 = gql`{ bar { ...TestEmbedded } } fragment TestEmbeddedTwo on Bar { field }`;
371
-
372
- assert.equal(warnings.length, 0);
373
- });
374
+ describe('unique fragments', () => {
375
+ beforeEach(() => {
376
+ gql.resetCaches();
374
377
  });
375
378
 
376
- describe('unique fragments', () => {
377
- beforeEach(() => {
378
- gqlRequire.resetCaches();
379
- });
380
-
381
- it('strips duplicate fragments from the document', () => {
382
- const frag1 = gql`fragment TestDuplicate on Bar { field }`;
383
- const query1 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1} ${frag1}`;
384
- const query2 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1}`;
385
-
386
- assert.equal(query1.definitions.length, 2);
387
- assert.equal(query1.definitions[1].kind, 'FragmentDefinition');
388
- // We don't test strict equality between the two queries because the source.body parsed from the
389
- // document is not the same, but the set of definitions should be.
390
- assert.deepEqual(query1.definitions, query2.definitions);
391
- });
392
-
393
- it('ignores duplicate fragments from second-level imports when using the webpack loader', () => {
394
- // take a require function and a query string, use the webpack loader to process it
395
- const load = (require, query) => {
396
- const jsSource = loader.call({ cacheable() {} }, query);
397
- const module = { exports: undefined };
398
- eval(jsSource);
399
- return module.exports;
400
- }
379
+ it('strips duplicate fragments from the document', () => {
380
+ const frag1 = gql`fragment TestDuplicate on Bar { field }`;
381
+ const query1 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1} ${frag1}`;
382
+ const query2 = gql`{ bar { fieldOne ...TestDuplicate } } ${frag1}`;
401
383
 
402
- const test_require = (path) => {
403
- switch (path) {
404
- case './friends.graphql':
405
- return load(test_require, [
406
- '#import "./person.graphql"',
407
- 'fragment friends on Hero { friends { ...person } }',
408
- ].join('\n'));
409
- case './enemies.graphql':
410
- return load(test_require, [
411
- '#import "./person.graphql"',
412
- 'fragment enemies on Hero { enemies { ...person } }',
413
- ].join('\n'));
414
- case './person.graphql':
415
- return load(test_require, 'fragment person on Person { name }\n');
416
- default:
417
- return null;
418
- };
419
- };
420
-
421
- const result = load(test_require, [
422
- '#import "./friends.graphql"',
423
- '#import "./enemies.graphql"',
424
- 'query { hero { ...friends ...enemies } }',
425
- ].join('\n'));
426
-
427
- assert.equal(result.kind, 'Document');
428
- assert.equal(result.definitions.length, 4, 'after deduplication, only 4 fragments should remain');
429
- assert.equal(result.definitions[0].kind, 'OperationDefinition');
430
-
431
- // the rest of the definitions should be fragments and contain one of
432
- // each: "friends", "enemies", "person". Order does not matter
433
- const fragments = result.definitions.slice(1)
434
- assert(fragments.every(fragment => fragment.kind === 'FragmentDefinition'))
435
- assert(fragments.some(fragment => fragment.name.value === 'friends'))
436
- assert(fragments.some(fragment => fragment.name.value === 'enemies'))
437
- assert(fragments.some(fragment => fragment.name.value === 'person'))
438
- });
384
+ assert.equal(query1.definitions.length, 2);
385
+ assert.equal(query1.definitions[1].kind, 'FragmentDefinition');
386
+ // We don't test strict equality between the two queries because the source.body parsed from the
387
+ // document is not the same, but the set of definitions should be.
388
+ assert.deepEqual(query1.definitions, query2.definitions);
439
389
  });
440
390
 
441
- // How to make this work?
442
- // it.only('can reference a fragment passed as a document via shorthand', () => {
443
- // const ast = gql`
444
- // {
445
- // user(id: 5) {
446
- // ...${userFragmentDocument}
447
- // }
448
- // }
449
- // `;
450
- //
451
- // assert.deepEqual(ast, gql`
452
- // {
453
- // user(id: 5) {
454
- // ...UserFragment
455
- // }
456
- // }
457
- // fragment UserFragment on User {
458
- // firstName
459
- // lastName
460
- // }
461
- // `);
462
- // });
391
+ it('ignores duplicate fragments from second-level imports when using the webpack loader', () => {
392
+ // take a require function and a query string, use the webpack loader to process it
393
+ const load = (require, query) => {
394
+ const jsSource = loader.call({ cacheable() {} }, query);
395
+ const module = { exports: undefined };
396
+ eval(jsSource);
397
+ return module.exports;
398
+ }
399
+
400
+ const test_require = (path) => {
401
+ switch (path) {
402
+ case './friends.graphql':
403
+ return load(test_require, [
404
+ '#import "./person.graphql"',
405
+ 'fragment friends on Hero { friends { ...person } }',
406
+ ].join('\n'));
407
+ case './enemies.graphql':
408
+ return load(test_require, [
409
+ '#import "./person.graphql"',
410
+ 'fragment enemies on Hero { enemies { ...person } }',
411
+ ].join('\n'));
412
+ case './person.graphql':
413
+ return load(test_require, 'fragment person on Person { name }\n');
414
+ default:
415
+ return null;
416
+ };
417
+ };
463
418
 
419
+ const result = load(test_require, [
420
+ '#import "./friends.graphql"',
421
+ '#import "./enemies.graphql"',
422
+ 'query { hero { ...friends ...enemies } }',
423
+ ].join('\n'));
424
+
425
+ assert.equal(result.kind, 'Document');
426
+ assert.equal(result.definitions.length, 4, 'after deduplication, only 4 fragments should remain');
427
+ assert.equal(result.definitions[0].kind, 'OperationDefinition');
428
+
429
+ // the rest of the definitions should be fragments and contain one of
430
+ // each: "friends", "enemies", "person". Order does not matter
431
+ const fragments = result.definitions.slice(1)
432
+ assert(fragments.every(fragment => fragment.kind === 'FragmentDefinition'))
433
+ assert(fragments.some(fragment => fragment.name.value === 'friends'))
434
+ assert(fragments.some(fragment => fragment.name.value === 'enemies'))
435
+ assert(fragments.some(fragment => fragment.name.value === 'person'))
436
+ });
464
437
  });
438
+
439
+ // How to make this work?
440
+ // it.only('can reference a fragment passed as a document via shorthand', () => {
441
+ // const ast = gql`
442
+ // {
443
+ // user(id: 5) {
444
+ // ...${userFragmentDocument}
445
+ // }
446
+ // }
447
+ // `;
448
+ //
449
+ // assert.deepEqual(ast, gql`
450
+ // {
451
+ // user(id: 5) {
452
+ // ...UserFragment
453
+ // }
454
+ // }
455
+ // fragment UserFragment on User {
456
+ // firstName
457
+ // lastName
458
+ // }
459
+ // `);
460
+ // });
465
461
  });