FunctionDataFetch throws InvocationException.cause property when available (#225)

* FunctionDataFetch throws InvocationException cause property when available.

This allows thrown `GraphQLException` instances to be handled by
`graph-java` as it would if thrown directly by a `DataFetcher` lambda.

* Include necessary test modules

* Fix linting issues

* Just return a string

Author: rharriso

src/main/kotlin/com/expedia/graphql/execution/FunctionDataFetcher.kt

@@ -11,6 +11,7 @@ import graphql.schema.DataFetchingEnvironment
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.future.asCompletableFuture
+import java.lang.reflect.InvocationTargetException
 import kotlin.reflect.KFunction
 import kotlin.reflect.KParameter
 import kotlin.reflect.full.callSuspend
@@ -46,7 +47,11 @@ class FunctionDataFetcher(
                     fn.callSuspend(it, *parameterValues)
                 }.asCompletableFuture()
             } else {
-                fn.call(it, *parameterValues)
+                try {
+                    return fn.call(it, *parameterValues)
+                } catch (exception: InvocationTargetException) {
+                    throw exception.cause ?: exception
+                }
             }
         }
     }

src/test/kotlin/com/expedia/graphql/execution/FunctionDataFetcherTest.kt

@@ -2,6 +2,7 @@ package com.expedia.graphql.execution
 
 import com.expedia.graphql.annotations.GraphQLContext
 import com.expedia.graphql.exceptions.CouldNotCastArgumentException
+import graphql.GraphQLException
 import graphql.schema.DataFetchingEnvironment
 import io.mockk.every
 import io.mockk.mockk
@@ -12,7 +13,9 @@ import java.util.concurrent.CompletableFuture
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertNull
+import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
+import kotlin.test.assertFalse
 
 internal class FunctionDataFetcherTest {
 
@@ -31,6 +34,13 @@ internal class FunctionDataFetcherTest {
             delay(10)
             string
         }
+
+        fun throwException() { throw GraphQLException("Test Exception") }
+
+        suspend fun suspendThrow(): String = coroutineScope {
+            delay(10)
+            throw GraphQLException("Suspended Exception")
+        }
     }
 
     @Test
@@ -126,4 +136,34 @@ internal class FunctionDataFetcherTest {
         assertTrue(result is CompletableFuture<*>)
         assertEquals(expected = "hello", actual = result.get())
     }
+
+    @Test
+    fun `throwException function propagates the original exception`() {
+        val dataFetcher = FunctionDataFetcher(target = MyClass(), fn = MyClass::throwException)
+        val mockEnvironmet: DataFetchingEnvironment = mockk()
+
+        try {
+            dataFetcher.get(mockEnvironmet)
+            assertFalse(true, "Should not be here")
+        } catch (e: Exception) {
+            assertEquals(e.message, "Test Exception")
+        }
+    }
+
+    @Test
+    fun `suspendThrow throws exception when resolved`() {
+        val dataFetcher = FunctionDataFetcher(target = MyClass(), fn = MyClass::suspendThrow)
+        val mockEnvironmet: DataFetchingEnvironment = mockk()
+
+        try {
+            val result = dataFetcher.get(mockEnvironmet)
+            assertTrue(result is CompletableFuture<*>)
+            result.get()
+            assertFalse(true, "Should not be here")
+        } catch (e: Exception) {
+            val message = e.message
+            assertNotNull(message)
+            assertTrue(message.endsWith("Suspended Exception"))
+        }
+    }
 }