Read error JSON

This way we will not have to look for a println when there is an issue
with the tests.  This will also help in production because we will log
the actual JSON error we get back instead of just the HTTP status.

Author: code-asher

src/main/kotlin/com/coder/gateway/sdk/BaseCoderRestClient.kt

@@ -36,7 +36,6 @@ import okhttp3.logging.HttpLoggingInterceptor
 import org.imgscalr.Scalr
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
-import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
 import java.time.Instant
@@ -103,6 +102,11 @@ open class BaseCoderRestClient(
             .build().create(CoderV2RestFacade::class.java)
     }
 
+    private fun <T> error(action: String, res: retrofit2.Response<T>): String {
+        val details = res.errorBody()?.charStream()?.use{ it.readText() } ?: "no details provided"
+        return "Unable to $action: url=$url, code=${res.code()}, details=$details"
+    }
+
     /**
      * Authenticate and load information about the current user and the build
      * version.
@@ -122,11 +126,7 @@ open class BaseCoderRestClient(
     fun me(): User {
         val userResponse = retroRestClient.me().execute()
         if (!userResponse.isSuccessful) {
-            throw AuthenticationResponseException(
-                "Unable to authenticate to $url: code ${userResponse.code()}, ${
-                    userResponse.message().ifBlank { "has your token expired?" }
-                }"
-            )
+            throw AuthenticationResponseException(error("authenticate", userResponse))
         }
 
         return userResponse.body()!!
@@ -139,11 +139,7 @@ open class BaseCoderRestClient(
     fun workspaces(): List<Workspace> {
         val workspacesResponse = retroRestClient.workspaces("owner:me").execute()
         if (!workspacesResponse.isSuccessful) {
-            throw WorkspaceResponseException(
-                "Unable to retrieve workspaces from $url: code ${workspacesResponse.code()}, reason: ${
-                    workspacesResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw WorkspaceResponseException(error("retrieve workspaces", workspacesResponse))
         }
 
         return workspacesResponse.body()!!.workspaces
@@ -169,31 +165,23 @@ open class BaseCoderRestClient(
     fun resources(workspace: Workspace): List<WorkspaceResource> {
         val resourcesResponse = retroRestClient.templateVersionResources(workspace.latestBuild.templateVersionID).execute()
         if (!resourcesResponse.isSuccessful) {
-            throw WorkspaceResponseException(
-                "Unable to retrieve template resources for ${workspace.name} from $url: code ${resourcesResponse.code()}, reason: ${
-                    resourcesResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw WorkspaceResponseException(error("retrieve resources for ${workspace.name}", resourcesResponse))
         }
         return resourcesResponse.body()!!
     }
 
     fun buildInfo(): BuildInfo {
         val buildInfoResponse = retroRestClient.buildInfo().execute()
         if (!buildInfoResponse.isSuccessful) {
-            throw java.lang.IllegalStateException("Unable to retrieve build information for $url, code: ${buildInfoResponse.code()}, reason: ${buildInfoResponse.message().ifBlank { "no reason provided" }}")
+            throw java.lang.IllegalStateException(error("retrieve build information", buildInfoResponse))
         }
         return buildInfoResponse.body()!!
     }
 
     private fun template(templateID: UUID): Template {
         val templateResponse = retroRestClient.template(templateID).execute()
         if (!templateResponse.isSuccessful) {
-            throw TemplateResponseException(
-                "Unable to retrieve template with ID $templateID from $url, code: ${templateResponse.code()}, reason: ${
-                    templateResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw TemplateResponseException(error("retrieve template with ID $templateID", templateResponse))
         }
         return templateResponse.body()!!
     }
@@ -202,11 +190,7 @@ open class BaseCoderRestClient(
         val buildRequest = CreateWorkspaceBuildRequest(null, WorkspaceTransition.START, null, null, null, null)
         val buildResponse = retroRestClient.createWorkspaceBuild(workspaceID, buildRequest).execute()
         if (buildResponse.code() != HttpURLConnection.HTTP_CREATED) {
-            throw WorkspaceResponseException(
-                "Unable to build workspace $workspaceName on $url, code: ${buildResponse.code()}, reason: ${
-                    buildResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw WorkspaceResponseException(error("start workspace $workspaceName", buildResponse))
         }
 
         return buildResponse.body()!!
@@ -216,11 +200,7 @@ open class BaseCoderRestClient(
         val buildRequest = CreateWorkspaceBuildRequest(null, WorkspaceTransition.STOP, null, null, null, null)
         val buildResponse = retroRestClient.createWorkspaceBuild(workspaceID, buildRequest).execute()
         if (buildResponse.code() != HttpURLConnection.HTTP_CREATED) {
-            throw WorkspaceResponseException(
-                "Unable to stop workspace $workspaceName on $url, code: ${buildResponse.code()}, reason: ${
-                    buildResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw WorkspaceResponseException(error("stop workspace $workspaceName", buildResponse))
         }
 
         return buildResponse.body()!!
@@ -245,11 +225,7 @@ open class BaseCoderRestClient(
             CreateWorkspaceBuildRequest(template.activeVersionID, WorkspaceTransition.START, null, null, null, null)
         val buildResponse = retroRestClient.createWorkspaceBuild(workspaceID, buildRequest).execute()
         if (buildResponse.code() != HttpURLConnection.HTTP_CREATED) {
-            throw WorkspaceResponseException(
-                "Unable to update workspace $workspaceName on $url, code: ${buildResponse.code()}, reason: ${
-                    buildResponse.message().ifBlank { "no reason provided" }
-                }"
-            )
+            throw WorkspaceResponseException(error("update workspace $workspaceName", buildResponse))
         }
 
         return buildResponse.body()!!

src/main/kotlin/com/coder/gateway/sdk/v2/models/Response.kt

@@ -0,0 +1,14 @@
+package com.coder.gateway.sdk.v2.models
+
+import com.google.gson.annotations.SerializedName
+
+data class Validation (
+    @SerializedName("field") val field: String,
+    @SerializedName("detail") val detail: String,
+)
+
+data class Response (
+    @SerializedName("message") val message: String,
+    @SerializedName("detail") val detail: String,
+    @SerializedName("validations") val validations: List<Validation> = emptyList(),
+)

src/test/kotlin/com/coder/gateway/sdk/BaseCoderRestClientTest.kt

@@ -30,24 +30,34 @@ import java.time.Instant
 import java.util.UUID
 import javax.net.ssl.SSLHandshakeException
 import javax.net.ssl.SSLPeerUnverifiedException
+import kotlin.test.assertContains
 import kotlin.test.assertFailsWith
 
-class BaseHttpHandler(private val method: String,
+internal fun toJson(src: Any?): String {
+    return GsonBuilder().registerTypeAdapter(Instant::class.java, InstantConverter()).create().toJson(src)
+}
+
+internal class BaseHttpHandler(private val method: String,
                       private val handler: (exchange: HttpExchange) -> Unit): HttpHandler {
     override fun handle(exchange: HttpExchange) {
         try {
             if (exchange.requestMethod != method) {
-                exchange.sendResponseHeaders(HttpURLConnection.HTTP_BAD_METHOD, 0)
+                val body = toJson(Response("Not allowed", "Expected $method but got ${exchange.requestMethod}")).toByteArray()
+                exchange.sendResponseHeaders(HttpURLConnection.HTTP_BAD_METHOD, body.size.toLong())
+                exchange.responseBody.write(body)
             } else {
                 handler(exchange)
                 if (exchange.responseCode == -1) {
-                    exchange.sendResponseHeaders(HttpURLConnection.HTTP_NOT_FOUND, 0)
+                    val body = toJson(Response("Not found", "The requested resource could not be found")).toByteArray()
+                    exchange.sendResponseHeaders(HttpURLConnection.HTTP_NOT_FOUND, body.size.toLong())
+                    exchange.responseBody.write(body)
                 }
             }
         } catch (ex: Exception) {
             // If we get here it is because of developer error.
-            println(ex)
-            exchange.sendResponseHeaders(HttpURLConnection.HTTP_INTERNAL_ERROR, 0)
+            val body = toJson(Response("Developer error", ex.message ?: "unknown error")).toByteArray()
+            exchange.sendResponseHeaders(HttpURLConnection.HTTP_BAD_REQUEST, body.size.toLong())
+            exchange.responseBody.write(body)
         }
         exchange.close()
     }
@@ -65,10 +75,6 @@ class BaseCoderRestClientTest {
         return Pair(srv, "http://localhost:" + srv.address.port)
     }
 
-    private fun toJson(src: Any?): String {
-        return GsonBuilder().registerTypeAdapter(Instant::class.java, InstantConverter()).create().toJson(src)
-    }
-
     private fun mockTLSServer(certName: String): Pair<HttpServer, String> {
         val srv = HttpsServer.create(InetSocketAddress(0), 0)
         val sslContext = sslContextFromPEMs(
@@ -226,10 +232,11 @@ class BaseCoderRestClientTest {
 
         // Fails to stop a non-existent workspace.
         val badWorkspace = DataGen.workspace("bad")
-        assertFailsWith(
+        val ex = assertFailsWith(
             exceptionClass = WorkspaceResponseException::class,
             block = { client.updateWorkspace(badWorkspace.id, badWorkspace.name, badWorkspace.latestBuild.transition, badWorkspace.templateID) })
         assertEquals(listOf(Pair("stop", badWorkspace.id)), actions)
+        assertContains(ex.message.toString(), "The requested resource could not be found")
         actions.clear()
 
         // When workspace is started it should stop first.