Add tests for remaining transforms with defer

test/src/test/kotlin/graphql/nadel/tests/next/fixtures/defer/transforms/DeferWithTransformThrowsErrorTest.kt

@@ -0,0 +1,62 @@
+package graphql.nadel.tests.next.fixtures.defer.transforms
+
+import graphql.nadel.NadelExecutionHints
+import graphql.nadel.tests.next.NadelIntegrationTest
+
+open class DeferWithTransformThrowsErrorTest : NadelIntegrationTest(
+    query = """
+      query {
+        defer {
+          hello
+          ... @defer(label: "slow-defer") {
+            slow
+          }
+        }
+      }
+    """.trimIndent(),
+    services = listOf(
+        Service(
+            name = "defer",
+            overallSchema = """
+                directive @defer(if: Boolean, label: String) on FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+                type Query {
+                  defer: DeferApi
+                }
+                type DeferApi {
+                  hello: String
+                  slow: String @renamed(from: "underlyingSlow")
+                }
+
+            """.trimIndent(),
+            runtimeWiring = { wiring ->
+                data class DeferApi(
+                    val hello: String,
+                    val slow: String,
+                )
+
+                wiring
+                    .type("Query") { type ->
+                        type
+                            .dataFetcher("defer") { env ->
+                                Any()
+                            }
+                    }
+                    .type("DeferApi") { type ->
+                        type
+                            .dataFetcher("hello") { env ->
+                                "helloString"
+                            }
+                            .dataFetcher("underlyingSlow") { env ->
+                                throw RuntimeException("An error occurred while fetching 'slow'")
+                            }
+                    }
+            },
+        ),
+    ),
+) {
+    override fun makeExecutionHints(): NadelExecutionHints.Builder {
+        return super.makeExecutionHints()
+            .deferSupport { true }
+    }
+}

test/src/test/kotlin/graphql/nadel/tests/next/fixtures/defer/transforms/DeferWithTransformThrowsErrorTestSnapshot.kt

@@ -0,0 +1,167 @@
+// @formatter:off
+package graphql.nadel.tests.next.fixtures.defer.transforms
+
+import graphql.nadel.tests.next.ExpectedNadelResult
+import graphql.nadel.tests.next.ExpectedServiceCall
+import graphql.nadel.tests.next.TestSnapshot
+import graphql.nadel.tests.next.listOfJsonStrings
+import kotlin.Suppress
+import kotlin.collections.List
+import kotlin.collections.listOf
+
+private suspend fun main() {
+    graphql.nadel.tests.next.update<DeferWithTransformThrowsErrorTest>()
+}
+
+/**
+ * This class is generated. Do NOT modify.
+ *
+ * Refer to [graphql.nadel.tests.next.UpdateTestSnapshots
+ */
+@Suppress("unused")
+public class DeferWithTransformThrowsErrorTestSnapshot : TestSnapshot() {
+    override val calls: List<ExpectedServiceCall> = listOf(
+            ExpectedServiceCall(
+                service = "defer",
+                query = """
+                | {
+                |   defer {
+                |     hello
+                |     ... @defer(label: "slow-defer") {
+                |       rename__slow__underlyingSlow: underlyingSlow
+                |       __typename__rename__slow: __typename
+                |     }
+                |   }
+                | }
+                """.trimMargin(),
+                variables = " {}",
+                result = """
+                | {
+                |   "data": {
+                |     "defer": {
+                |       "hello": "helloString"
+                |     }
+                |   },
+                |   "hasNext": true
+                | }
+                """.trimMargin(),
+                delayedResults = listOfJsonStrings(
+                    """
+                    | {
+                    |   "hasNext": false,
+                    |   "incremental": [
+                    |     {
+                    |       "path": [
+                    |         "defer"
+                    |       ],
+                    |       "label": "slow-defer",
+                    |       "errors": [
+                    |         {
+                    |           "message": "Exception while fetching data (/defer/rename__slow__underlyingSlow) : An error occurred while fetching 'slow'",
+                    |           "locations": [
+                    |             {
+                    |               "line": 5,
+                    |               "column": 7
+                    |             }
+                    |           ],
+                    |           "path": [
+                    |             "defer",
+                    |             "rename__slow__underlyingSlow"
+                    |           ],
+                    |           "extensions": {
+                    |             "classification": "DataFetchingException"
+                    |           }
+                    |         }
+                    |       ],
+                    |       "data": {
+                    |         "rename__slow__underlyingSlow": null,
+                    |         "__typename__rename__slow": "DeferApi"
+                    |       }
+                    |     }
+                    |   ]
+                    | }
+                    """.trimMargin(),
+                ),
+            ),
+        )
+
+    /**
+     * ```json
+     * {
+     *   "data": {
+     *     "defer": {
+     *       "hello": "helloString",
+     *       "slow": null
+     *     }
+     *   },
+     *   "errors": [
+     *     {
+     *       "message": "Exception while fetching data (/defer/rename__slow__underlyingSlow) : An
+     * error occurred while fetching 'slow'",
+     *       "locations": [
+     *         {
+     *           "line": 5,
+     *           "column": 7
+     *         }
+     *       ],
+     *       "path": [
+     *         "defer",
+     *         "rename__slow__underlyingSlow"
+     *       ],
+     *       "extensions": {
+     *         "classification": "DataFetchingException"
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     */
+    override val result: ExpectedNadelResult = ExpectedNadelResult(
+            result = """
+            | {
+            |   "data": {
+            |     "defer": {
+            |       "hello": "helloString"
+            |     }
+            |   },
+            |   "hasNext": true
+            | }
+            """.trimMargin(),
+            delayedResults = listOfJsonStrings(
+                """
+                | {
+                |   "hasNext": false,
+                |   "incremental": [
+                |     {
+                |       "path": [
+                |         "defer"
+                |       ],
+                |       "label": "slow-defer",
+                |       "errors": [
+                |         {
+                |           "message": "Exception while fetching data (/defer/rename__slow__underlyingSlow) : An error occurred while fetching 'slow'",
+                |           "locations": [
+                |             {
+                |               "line": 5,
+                |               "column": 7
+                |             }
+                |           ],
+                |           "path": [
+                |             "defer",
+                |             "rename__slow__underlyingSlow"
+                |           ],
+                |           "extensions": {
+                |             "classification": "DataFetchingException"
+                |           }
+                |         }
+                |       ],
+                |       "data": {
+                |         "slow": null
+                |       }
+                |     }
+                |   ]
+                | }
+                """.trimMargin(),
+            ),
+        )
+}

test/src/test/kotlin/graphql/nadel/tests/next/fixtures/defer/transforms/DeferredRenamedInputTypeTest.kt

@@ -0,0 +1,87 @@
+package graphql.nadel.tests.next.fixtures.defer.transforms
+
+import graphql.nadel.NadelExecutionHints
+import graphql.nadel.tests.next.NadelIntegrationTest
+
+/**
+ * The `ConfluenceLegacyPathType` input type was renamed.
+ *
+ * In the test snapshot we ensure the variable is defined as `PathType`.
+ *
+ * This tests the NadelRenameArgumentInputTypesTransform with defer
+ */
+class DeferredRenamedInputTypeTest : NadelIntegrationTest(
+    query = """
+      query {
+        me {
+          profilePicture {
+            ...@defer {
+              path(type: ABSOLUTE)
+            }
+          }
+        }
+      }
+    """.trimIndent(),
+    services = listOf(
+        Service(
+            name = "confluence_legacy",
+            overallSchema = """
+                type Query {
+                  me: ConfluenceLegacyUser
+                }
+                type ConfluenceLegacyUser @renamed(from: "User") {
+                  profilePicture: ConfluenceLegacyProfilePicture
+                }
+                type ConfluenceLegacyProfilePicture @renamed(from: "ProfilePicture") {
+                  path(type: ConfluenceLegacyPathType!): String
+                }
+                enum ConfluenceLegacyPathType @renamed(from: "PathType") {
+                  ABSOLUTE
+                  RELATIVE
+                }
+            """.trimIndent(),
+            runtimeWiring = { wiring ->
+                data class ProfilePicture(
+                    val absolutePath: String,
+                    val relativePath: String,
+                )
+
+                data class User(
+                    val profilePicture: ProfilePicture,
+                )
+
+                wiring
+                    .type("Query") { type ->
+                        type
+                            .dataFetcher("me") { env ->
+                                User(
+                                    profilePicture = ProfilePicture(
+                                        relativePath = "/wiki/aa-avatar/5ee0a4ef55749e0ab6e0fb70",
+                                        absolutePath = "https://atlassian.net/wiki/aa-avatar/5ee0a4ef55749e0ab6e0fb70",
+                                    ),
+                                )
+                            }
+                    }
+                    .type("ProfilePicture") { type ->
+                        type
+                            .dataFetcher("path") { env ->
+                                val pfp = env.getSource<ProfilePicture>()!!
+                                when (val urlType = env.getArgument<String>("type")) {
+                                    "ABSOLUTE" -> pfp.absolutePath
+                                    "RELATIVE" -> pfp.relativePath
+                                    else -> throw IllegalArgumentException(urlType)
+                                }
+                            }
+                    }
+            },
+        ),
+    ),
+) {
+    override fun makeExecutionHints(): NadelExecutionHints.Builder {
+        return super.makeExecutionHints()
+            // todo: this should be on by default
+            .allDocumentVariablesHint {
+                true
+            }
+    }
+}