refactor: further simplifications and improvements

marc0der · marc0der · commit 41b4e77dc5a6 · 2025-08-15T12:06:39.000+01:00
diff --git a/src/main/kotlin/io/sdkman/broker/adapter/primary/rest/HealthResponseHandlers.kt b/src/main/kotlin/io/sdkman/broker/adapter/primary/rest/HealthResponseHandlers.kt
@@ -6,6 +6,7 @@ import io.ktor.server.response.respond
 import io.sdkman.broker.application.service.DatabaseHealthStatus
 import io.sdkman.broker.application.service.HealthCheckError
 import io.sdkman.broker.application.service.HealthStatus
+import kotlinx.serialization.Serializable
 
 enum class DatabaseName(val displayName: String) {
     MONGODB("MongoDB"),
@@ -33,7 +34,8 @@ suspend fun ApplicationCall.handleDatabaseHealthStatus(databaseStatus: DatabaseH
     val overallHealthy = databaseStatus.mongodb == HealthStatus.UP && databaseStatus.postgres == HealthStatus.UP
     val statusCode = if (overallHealthy) HttpStatusCode.OK else HttpStatusCode.ServiceUnavailable
 
-    respond(statusCode, DetailedHealthResponse(mongoDbStatus, postgresStatus))
+    val reason = "Service is ${if (overallHealthy) "healthy" else "not healthy"}"
+    respond(statusCode, DetailedHealthResponse(mongoDbStatus, postgresStatus, reason))
 }
 
 suspend fun ApplicationCall.handleHealthError(error: HealthCheckError) {
@@ -110,3 +112,6 @@ private fun createDatabaseErrorResponse(
             )
     }
 }
+
+@Serializable
+data class DetailedHealthResponse(val mongodb: String, val postgres: String, val reason: String)
diff --git a/src/main/kotlin/io/sdkman/broker/adapter/primary/rest/MetaRoutes.kt b/src/main/kotlin/io/sdkman/broker/adapter/primary/rest/MetaRoutes.kt
@@ -7,7 +7,6 @@ import io.ktor.server.response.respond
 import io.ktor.server.routing.get
 import io.ktor.server.routing.routing
 import io.sdkman.broker.application.service.MetaHealthService
-import io.sdkman.broker.application.service.MetaError
 import io.sdkman.broker.application.service.MetaReleaseService
 import kotlinx.serialization.Serializable
 
@@ -30,7 +29,7 @@ fun Application.metaRoutes(
                     { error ->
                         call.respond(
                             HttpStatusCode.InternalServerError,
-                            ReleaseErrorResponse("Error retrieving release: ${error.cause.message}")
+                            ReleaseErrorResponse("Error retrieving release: ${error.message}")
                         )
                     },
                     { release ->
@@ -41,17 +40,8 @@ fun Application.metaRoutes(
     }
 }
 
-@Serializable
-data class DetailedHealthResponse(val mongodb: String, val postgres: String, val reason: String? = null)
-
 @Serializable
 data class ReleaseResponse(val release: String)
 
 @Serializable
 data class ReleaseErrorResponse(val error: String)
-
-private val MetaError.cause: Throwable
-    get() =
-        when (this) {
-            is MetaError.MetaFileError -> cause
-        }
diff --git a/src/main/kotlin/io/sdkman/broker/application/service/MetaReleaseService.kt b/src/main/kotlin/io/sdkman/broker/application/service/MetaReleaseService.kt
@@ -9,7 +9,7 @@ import arrow.core.toOption
 import java.util.Properties
 
 interface MetaReleaseService {
-    fun getReleaseVersion(): Either<MetaError, String>
+    fun getReleaseVersion(): Either<MetaReleaseError, String>
 }
 
 class MetaReleaseServiceImpl(
@@ -20,11 +20,11 @@ class MetaReleaseServiceImpl(
         private const val RELEASE_KEY = "release"
     }
 
-    override fun getReleaseVersion(): Either<MetaError, String> =
+    override fun getReleaseVersion(): Either<MetaReleaseError, String> =
         loadPropertiesFile()
             .flatMap { properties -> getReleaseFromProperties(properties) }
 
-    private fun loadPropertiesFile(): Either<MetaError, Properties> =
+    private fun loadPropertiesFile(): Either<MetaReleaseError, Properties> =
         Either.catch {
             val properties = Properties()
             classLoader.getResourceAsStream(RELEASE_PROPERTIES).toOption()
@@ -35,18 +35,19 @@ class MetaReleaseServiceImpl(
                         properties
                     }
                 )
-        }.mapLeft { MetaError.MetaFileError(it) }
+        }.mapLeft { MetaReleaseError(it) }
 
-    private fun getReleaseFromProperties(properties: Properties): Either<MetaError, String> =
+    private fun getReleaseFromProperties(properties: Properties): Either<MetaReleaseError, String> =
         properties.getProperty(RELEASE_KEY).toOption()
             .filter { it.isNotBlank() }
             .map { it.right() }
             .getOrElse {
-                MetaError.MetaFileError(IllegalStateException("Release property not found in $RELEASE_PROPERTIES"))
+                MetaReleaseError(IllegalStateException("Release property not found in $RELEASE_PROPERTIES"))
                     .left()
             }
 }
 
-sealed class MetaError {
-    data class MetaFileError(val cause: Throwable) : MetaError()
+class MetaReleaseError(e: Throwable) : Throwable(e) {
+    override val message: String
+        get() = super.message ?: "An error occurred while retrieving the release version."
 }
diff --git a/src/test/kotlin/io/sdkman/broker/acceptance/MetaReleaseEndpointAcceptanceSpec.kt b/src/test/kotlin/io/sdkman/broker/acceptance/MetaReleaseEndpointAcceptanceSpec.kt
@@ -8,7 +8,7 @@ import io.ktor.client.call.body
 import io.ktor.client.request.get
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.testing.testApplication
-import io.sdkman.broker.application.service.MetaError
+import io.sdkman.broker.application.service.MetaReleaseError
 import io.sdkman.broker.application.service.MetaReleaseService
 import io.sdkman.broker.support.TestDependencyInjection
 import io.sdkman.broker.support.configureAppForTesting
@@ -47,8 +47,8 @@ class MetaReleaseEndpointAcceptanceSpec : ShouldSpec({
             // Using a service that can't find the file
             val mockService =
                 object : MetaReleaseService {
-                    override fun getReleaseVersion(): Either<MetaError, String> =
-                        MetaError.MetaFileError(
+                    override fun getReleaseVersion(): Either<MetaReleaseError, String> =
+                        MetaReleaseError(
                             IllegalStateException("Could not load release.properties")
                         ).left()
                 }
diff --git a/src/test/kotlin/io/sdkman/broker/application/service/MetaReleaseServiceSpec.kt b/src/test/kotlin/io/sdkman/broker/application/service/MetaReleaseServiceSpec.kt
@@ -9,7 +9,7 @@ import io.sdkman.broker.support.beLeftAnd
 import io.sdkman.broker.support.shouldBeRight
 import java.io.ByteArrayInputStream
 
-class ReleaseServiceSpec : ShouldSpec({
+class MetaReleaseServiceSpec : ShouldSpec({
 
     should("successfully return release when properties file exists with valid release") {
         // given: a mocked classloader that returns a valid properties file
@@ -47,9 +47,9 @@ class ReleaseServiceSpec : ShouldSpec({
 
         // then: release file error is returned
         result should
-            beLeftAnd<MetaError, String> { error ->
-                error.shouldBeInstanceOf<MetaError.MetaFileError>()
-                error.cause.message?.contains("Release property not found") ?: false
+            beLeftAnd { error ->
+                error.shouldBeInstanceOf<MetaReleaseError>()
+                error.message.contains("Release property not found")
             }
     }
 
@@ -70,9 +70,9 @@ class ReleaseServiceSpec : ShouldSpec({
 
         // then: release file error is returned
         result should
-            beLeftAnd<MetaError, String> { error ->
-                error.shouldBeInstanceOf<MetaError.MetaFileError>()
-                error.cause.message?.contains("Release property not found") ?: false
+            beLeftAnd<MetaReleaseError, String> { error ->
+                error.shouldBeInstanceOf<MetaReleaseError>()
+                error.message.contains("Release property not found")
             }
     }
 
@@ -91,9 +91,9 @@ class ReleaseServiceSpec : ShouldSpec({
 
         // then: release file error is returned
         result should
-            beLeftAnd<MetaError, String> { error ->
-                error.shouldBeInstanceOf<MetaError.MetaFileError>()
-                error.cause.message?.contains("Could not load") ?: false
+            beLeftAnd { error ->
+                error.shouldBeInstanceOf<MetaReleaseError>()
+                error.message.contains("Could not load")
             }
     }
 })
diff --git a/src/test/kotlin/io/sdkman/broker/domain/MetaHealthServiceSpec.kt b/src/test/kotlin/io/sdkman/broker/domain/MetaHealthServiceSpec.kt
@@ -3,15 +3,16 @@ package io.sdkman.broker.domain
 import arrow.core.Either
 import arrow.core.None
 import arrow.core.Some
+import arrow.core.getOrElse
 import arrow.core.left
 import arrow.core.right
 import io.kotest.core.spec.style.ShouldSpec
 import io.mockk.every
 import io.mockk.mockk
 import io.sdkman.broker.application.service.DatabaseHealthStatus
 import io.sdkman.broker.application.service.HealthCheckError
-import io.sdkman.broker.application.service.MetaHealthServiceImpl
 import io.sdkman.broker.application.service.HealthStatus
+import io.sdkman.broker.application.service.MetaHealthServiceImpl
 import io.sdkman.broker.domain.model.Application
 import io.sdkman.broker.domain.repository.ApplicationRepository
 import io.sdkman.broker.domain.repository.DatabaseFailure
@@ -21,12 +22,10 @@ import io.sdkman.broker.domain.repository.RepositoryError
 import io.sdkman.broker.support.shouldBeLeftAnd
 import io.sdkman.broker.support.shouldBeRight
 
-class HealthServiceSpec : ShouldSpec({
+class MetaHealthServiceSpec : ShouldSpec({
     val applicationOK =
-        Application.of("OK").fold(
-            { error -> throw IllegalStateException("Failed to create test application: $error") },
-            { it }
-        )
+        Application.of("OK")
+            .getOrElse { throw IllegalStateException("Failed to create test application: $it") }
 
     context("HealthServiceImpl with dual database checks") {
 
diff --git a/src/test/kotlin/io/sdkman/broker/support/TestDependencyInjection.kt b/src/test/kotlin/io/sdkman/broker/support/TestDependencyInjection.kt
@@ -14,7 +14,6 @@ import javax.sql.DataSource
 // Dependency injection for tests
 // Uses the shared MongoTestListener and PostgresTestListener to provide consistent database access across all tests
 object TestDependencyInjection {
-
     // Use the database from MongoTestListener directly
     val database by lazy { MongoTestListener.database }
 

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ import io.ktor.server.response.respond`
`6`	`6`	`import io.sdkman.broker.application.service.DatabaseHealthStatus`
`7`	`7`	`import io.sdkman.broker.application.service.HealthCheckError`
`8`	`8`	`import io.sdkman.broker.application.service.HealthStatus`
	`9`	`+import kotlinx.serialization.Serializable`
`9`	`10`
`10`	`11`	`enum class DatabaseName(val displayName: String) {`
`11`	`12`	`MONGODB("MongoDB"),`
`@@ -33,7 +34,8 @@ suspend fun ApplicationCall.handleDatabaseHealthStatus(databaseStatus: DatabaseH`
`33`	`34`	`val overallHealthy = databaseStatus.mongodb == HealthStatus.UP && databaseStatus.postgres == HealthStatus.UP`
`34`	`35`	`val statusCode = if (overallHealthy) HttpStatusCode.OK else HttpStatusCode.ServiceUnavailable`
`35`	`36`
`36`		`- respond(statusCode, DetailedHealthResponse(mongoDbStatus, postgresStatus))`
	`37`	`+ val reason = "Service is ${if (overallHealthy) "healthy" else "not healthy"}"`
	`38`	`+ respond(statusCode, DetailedHealthResponse(mongoDbStatus, postgresStatus, reason))`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`suspend fun ApplicationCall.handleHealthError(error: HealthCheckError) {`
`@@ -110,3 +112,6 @@ private fun createDatabaseErrorResponse(`
`110`	`112`	`)`
`111`	`113`	`}`
`112`	`114`	`}`
	`115`	`+`
	`116`	`+@Serializable`
	`117`	`+data class DetailedHealthResponse(val mongodb: String, val postgres: String, val reason: String)`