Add assertions for errors

Author: arian

src/main/kotlin/com/symbaloo/graphql/test/GraphQLKotlinTestDsl.kt

@@ -153,6 +153,24 @@ fun GraphQLResultMatcherDsl.noErrors() {
     }
 }
 
+/**
+ * Assert that there is at least one error
+ */
+fun GraphQLResultMatcherDsl.hasError(matcher: GraphQLErrorResultMatcher.() -> Unit = { }) {
+    val errors = this.executionResult.errors
+    if (errors.isEmpty()) {
+        fail(
+            """
+            |Expected at least one error in the result. But there were no errors.
+            |""".trimMargin(),
+            null,
+            errors
+        )
+    } else {
+        GraphQLErrorResultMatcher(errors).matcher()
+    }
+}
+
 /**
  * Assert that some field has some value
  */
@@ -277,6 +295,16 @@ internal class JsonPathContext(
     }
 }
 
+class GraphQLErrorResultMatcher(internal val errors: List<GraphQLError>)
+
+fun <R> GraphQLErrorResultMatcher.path(path: String, matcher: (GraphQLError) -> R) {
+    val parts = path.split(".")
+    when (val error = errors.find { it.path == parts }) {
+        null -> fail("Error with path '$path' couldn't be found", path, errors)
+        else -> matcher(error)
+    }
+}
+
 private fun fail(message: String, expected: Any?, value: Any?) {
     throw AssertionFailedError(
         "expected: <$expected> but was: <$value>",

src/test/kotlin/com/symbaloo/graphql/test/GraphQLKotlinTestDslTest.kt

@@ -13,6 +13,7 @@ import assertk.assertions.isNull
 import assertk.assertions.key
 import assertk.assertions.prop
 import assertk.assertions.startsWith
+import graphql.ExceptionWhileDataFetching
 import graphql.ExecutionResult
 import graphql.GraphQL
 import graphql.schema.idl.RuntimeWiring.newRuntimeWiring
@@ -33,6 +34,7 @@ private val schema = """
     |    echo(echo: String): String
     |    fromContext: String
     |    list: [Bar!]!
+    |    error: Int
     |}
     |type Bar {
     |    hello: String
@@ -52,6 +54,7 @@ class GraphQLKotlinTestDslTest {
                 builder.dataFetcher("echo") { it.arguments["echo"] }
                 builder.dataFetcher("fromContext") { it.getContext<Bar>().foo }
                 builder.dataFetcher("list") { listOf(Bar("first"), Bar("second")) }
+                builder.dataFetcher("error") { throw Exception("oops") }
             }
             .type("Bar") { builder ->
                 builder.dataFetcher("hello") { it.getSource<Bar>().foo }
@@ -375,6 +378,18 @@ class GraphQLKotlinTestDslTest {
                 assertThat(result).isEqualTo(10)
             }
         }
+
+        @Test
+        fun noErrors() {
+            assertThat {
+                graphQLTest(createTestSchema()) { query("{ error }") }.andExpect { noErrors() }
+            }.isFailure()
+        }
+
+        @Test
+        fun hasError() {
+            graphQLTest(createTestSchema()) { query("{ error }") }.andExpect { hasError() }
+        }
     }
 
     @Nested
@@ -430,6 +445,41 @@ class GraphQLKotlinTestDslTest {
             }
         }
     }
+
+    @Nested
+    inner class GraphQLErrorResultMatcher {
+
+        @Test
+        fun `assert error path`() {
+            graphQLTest(createTestSchema()) {
+                query("{ error }")
+            }
+                .andExpect {
+                    hasError {
+                        path("error") { error ->
+                            assertThat(error)
+                                .isInstanceOf(ExceptionWhileDataFetching::class)
+                                .transform { it.exception.message }
+                                .isEqualTo("oops")
+                        }
+                    }
+                }
+        }
+
+        @Test
+        fun `assert error of non-existing path`() {
+            assertThat {
+                graphQLTest(createTestSchema()) {
+                    query("{ error }")
+                }
+                    .andExpect {
+                        hasError {
+                            path("error.bar") { }
+                        }
+                    }
+            }.isFailure()
+        }
+    }
 }
 
 private fun GraphQLJsonResultMatcherDsl.assertPath(path: String): Assert<Any?> =