@@ -14,13 +14,17 @@ import defer.DoesNotDisableDeferWithNullIfArgumentQuery
1414import  defer.HandlesErrorsThrownInDeferredFragmentsQuery 
1515import  defer.HandlesNonNullableErrorsThrownInDeferredFragmentsQuery 
1616import  defer.HandlesNonNullableErrorsThrownOutsideDeferredFragmentsQuery 
17+ import  defer.Overlapping2Query 
18+ import  defer.OverlappingQuery 
19+ import  defer.SubPathQuery 
1720import  defer.WithFragmentSpreadsMutation 
1821import  defer.WithFragmentSpreadsQuery 
1922import  defer.WithInlineFragmentsQuery 
2023import  defer.fragment.ComputerErrorField 
2124import  defer.fragment.ComputerFields 
2225import  defer.fragment.FragmentOnQuery 
2326import  defer.fragment.ScreenFields 
27+ import  defer.notypename.SkippingEmptyFragmentQuery 
2428import  kotlinx.coroutines.flow.toList 
2529import  kotlin.test.Test 
2630import  kotlin.test.assertEquals 
@@ -357,4 +361,176 @@ class DeferWithApolloServerTest {
357361    val  actualResponseList =  apolloClient.query(query).toFlow().toList()
358362    assertResponseListEquals(expectedDataList, actualResponseList)
359363  }
364+ 
365+   @Test
366+   fun  overlapping () =  runTest(before =  { setUp() }, after =  { tearDown() }) {
367+     //  Expected payloads:
368+     //  {"data":{"computer":{"__typename":"Computer","id":"Computer1"}},"pending":[{"id":"0","path":["computer"],"label":"b"}],"hasNext":true}
369+     //  {"hasNext":false,"incremental":[{"data":{"cpu":"386","year":1993},"id":"0"}],"completed":[{"id":"0"}]}
370+     val  query =  OverlappingQuery ()
371+     val  uuid =  uuid4()
372+ 
373+     val  expectedDataList =  listOf (
374+         ApolloResponse .Builder (
375+             query,
376+             uuid,
377+         ).data(
378+             OverlappingQuery .Data (
379+                 OverlappingQuery .Computer (
380+                     " Computer"  , " Computer1"  , OverlappingQuery .OnComputer (
381+                     " Computer"  , " Computer1"  , null ,
382+                 )
383+                 )
384+             )
385+         )
386+             .build(),
387+ 
388+         ApolloResponse .Builder (
389+             query,
390+             uuid,
391+         ).data(
392+             OverlappingQuery .Data (
393+                 OverlappingQuery .Computer (
394+                     " Computer"  , " Computer1"  , OverlappingQuery .OnComputer (
395+                     " Computer"  , " Computer1"  , OverlappingQuery .OnComputer1 (" Computer1"  , " 386"  , 1993 )
396+                 )
397+                 )
398+             )
399+         )
400+             .build()
401+     )
402+     val  actualResponseList =  apolloClient.query(query).toFlow().toList()
403+     assertResponseListEquals(expectedDataList, actualResponseList)
404+   }
405+ 
406+   @Test
407+   fun  overlapping2 () =  runTest(before =  { setUp() }, after =  { tearDown() }) {
408+     //  Expected payloads:
409+     //  {"data":{"computer":{"__typename":"Computer","id":"Computer1"}},"pending":[{"id":"0","path":["computer"],"label":"b"}],"hasNext":true}
410+     //  {"hasNext":false,"incremental":[{"data":{"cpu":"386","year":1993},"id":"0"}],"completed":[{"id":"0"}]}
411+     val  query =  Overlapping2Query ()
412+     val  uuid =  uuid4()
413+ 
414+     val  expectedDataList =  listOf (
415+         ApolloResponse .Builder (
416+             query,
417+             uuid,
418+         ).data(
419+             Overlapping2Query .Data (
420+                 Overlapping2Query .Computer (
421+                     " Computer"  , " Computer1"  , Overlapping2Query .OnComputerDeferA (" Computer1" 
422+                 ), null 
423+                 )
424+             )
425+         )
426+             .build(),
427+         ApolloResponse .Builder (
428+             query,
429+             uuid,
430+         ).data(
431+             Overlapping2Query .Data (
432+                 Overlapping2Query .Computer (
433+                     " Computer"  , " Computer1"  , Overlapping2Query .OnComputerDeferA (" Computer1" 
434+                 ), Overlapping2Query .OnComputerDeferB (
435+                     " Computer1"  , " 386"  , 1993 
436+                 )
437+                 )
438+             )
439+         )
440+             .build()
441+     )
442+     val  actualResponseList =  apolloClient.query(query).toFlow().toList()
443+     assertResponseListEquals(expectedDataList, actualResponseList)
444+   }
445+ 
446+   @Test
447+   fun  subPath () =  runTest(before =  { setUp() }, after =  { tearDown() }) {
448+     //  Expected payloads:
449+     //  {"data":{"__typename":"Query","computer":{"id":"Computer1"}},"pending":[{"id":"0","path":[],"label":"a"}],"hasNext":true}
450+     //  {"hasNext":false,"incremental":[{"data":{"screen":{"isColor":false}},"id":"0","subPath":["computer"]},{"data":{"MyFragment":"Query"},"id":"0"}],"completed":[{"id":"0"}]}
451+     val  query =  SubPathQuery ()
452+     val  uuid =  uuid4()
453+ 
454+     val  expectedDataList =  listOf (
455+         ApolloResponse .Builder (
456+             query,
457+             uuid,
458+         ).data(
459+             SubPathQuery .Data (
460+                 " Query"  , SubPathQuery .Computer (
461+                 " Computer1" 
462+             ), null 
463+             )
464+         )
465+             .build(),
466+         ApolloResponse .Builder (
467+             query,
468+             uuid,
469+         ).data(
470+             SubPathQuery .Data (
471+                 " Query"  , SubPathQuery .Computer (
472+                 " Computer1" 
473+             ), SubPathQuery .OnQuery (
474+                 " Query"  , SubPathQuery .Computer1 (
475+                 " Computer1"  ,
476+                 SubPathQuery .Screen (false 
477+                 )
478+             )
479+             )
480+             )
481+         )
482+             .build()
483+     )
484+     val  actualResponseList =  apolloClient.query(query).toFlow().toList()
485+     assertResponseListEquals(expectedDataList, actualResponseList)
486+   }
487+ 
488+   @Test
489+   fun  skippingEmptyFragment () =  runTest(before =  { setUp() }, after =  { tearDown() }) {
490+     //  Expected payloads:
491+     //  {"data":{"computer":{}},"pending":[{"id":"0","path":["computer"],"label":"c"}],"hasNext":true}
492+     //  {"hasNext":false,"incremental":[{"data":{"id":"Computer1"},"id":"0"}],"completed":[{"id":"0"}]}
493+     val  query =  SkippingEmptyFragmentQuery ()
494+     val  uuid =  uuid4()
495+ 
496+     val  expectedDataList =  listOf (
497+         ApolloResponse .Builder (
498+             query,
499+             uuid,
500+         ).data(
501+             SkippingEmptyFragmentQuery .Data (
502+                 SkippingEmptyFragmentQuery .Computer (
503+                     SkippingEmptyFragmentQuery .OnComputer (
504+                         SkippingEmptyFragmentQuery .OnComputer1 (
505+                             null 
506+                         )
507+                     )
508+                 )
509+             )
510+         )
511+             .build(),
512+ 
513+         ApolloResponse .Builder (
514+             query,
515+             uuid,
516+         ).data(
517+             SkippingEmptyFragmentQuery .Data (
518+                 SkippingEmptyFragmentQuery .Computer (
519+                     SkippingEmptyFragmentQuery .OnComputer (
520+                         SkippingEmptyFragmentQuery .OnComputer1 (
521+                             SkippingEmptyFragmentQuery .OnComputer2 (
522+                                 " Computer1" 
523+                             )
524+                         )
525+                     )
526+                 )
527+             )
528+         )
529+             .build()
530+     )
531+     val  actualResponseList =  apolloClient.query(query).toFlow().toList()
532+     assertResponseListEquals(expectedDataList, actualResponseList)
533+   }
534+ 
535+ 
360536}
0 commit comments