refactor: improve error handling in ConfigurationService and ActivityService; add unit tests for ActivityService

Author: costa-alex

boot/src/main/kotlin/io/github/costaalex/workoutrelay/app/activity/ActivityService.kt

@@ -34,5 +34,10 @@ class ActivityService(
         return CopyActivitiesResponse(activitiesToSave.size, filteredOut, request.startDate, request.endDate)
     }
 
-    private fun getRepository(platform: Platform) = repositoryMap[platform]!!
+    private fun getRepository(
+        platform: Platform,
+    ): ActivityRepository =
+        checkNotNull(repositoryMap[platform]) {
+            "No ActivityRepository registered for platform $platform"
+        }
 }

boot/src/main/kotlin/io/github/costaalex/workoutrelay/app/configuration/ConfigurationService.kt

@@ -42,23 +42,19 @@ class ConfigurationService(
         val info = try {
             repository.platformInfo()
         } catch (exception: Exception) {
-            log.warn(
-                "Unable to validate connection to {}",
-                platform.title,
-                exception
-            )
+            log.warn("Unable to validate connection to {}", platform.title, exception)
 
-            PlatformInfo(
-                mapOf("isValid" to false)
-            )
+            PlatformInfo(mapOf("isValid" to false))
         }
 
         platform to info
     }
 
-    fun platformInfo(platform: Platform): PlatformInfo {
-        return platformInfoRepositoryMap[platform]!!.platformInfo()
-    }
+    fun platformInfo(
+        platform: Platform,
+    ): PlatformInfo =
+        getPlatformInfoRepository(platform)
+            .platformInfo()
 
     fun refreshPlatformInfo(): Map<Platform, PlatformInfo> {
         cacheManager
@@ -68,21 +64,40 @@ class ConfigurationService(
         return platformInfo()
     }
 
+    private fun getPlatformInfoRepository(
+        platform: Platform,
+    ): PlatformInfoRepository =
+        checkNotNull(
+            platformInfoRepositoryMap[platform]
+        ) {
+            "No PlatformInfoRepository registered for platform $platform"
+        }
+
     private fun handleDebugModeIfNecessary(request: UpdateConfigurationRequest) {
         debugModeService.handleDebugMode(request.configMap)
     }
 
     private fun updateConfiguration(
         request: UpdateConfigurationRequest,
-        repository: PlatformConfigurationRepository
+        repository: PlatformConfigurationRepository,
     ): String? {
         return try {
             repository.updateConfig(request)
             null
-        } catch (e: PlatformException) {
-            "${e.platform.title}: ${e.message}"
-        } catch (e: Exception) {
-            e.message
+        } catch (exception: PlatformException) {
+            "${exception.platform.title}: " +
+                (
+                    exception.message ?: "Unable to update configuration"
+                )
+        } catch (exception: Exception) {
+            val platform = repository.platform()
+
+            log.error("Unexpected error while updating configuration for {}", platform.title, exception)
+
+            "${platform.title}: " +
+                (
+                    exception.message ?: "Unexpected configuration error"
+                )
         }
     }
 }

boot/src/test/kotlin/io/github/costaalex/workoutrelay/app/activity/ActivityServiceTest.kt

@@ -0,0 +1,47 @@
+package io.github.costaalex.workoutrelay.app.activity
+
+import io.github.costaalex.workoutrelay.domain.Platform
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+class ActivityServiceTest {
+
+    @Test
+    fun `should fail with clear error when repository is missing`() {
+        val activityService =
+            ActivityService(emptyList())
+
+        val request =
+            CopyActivitiesRequest(
+                sourcePlatform =
+                    Platform.INTERVALS,
+                targetPlatform =
+                    Platform.TRAINING_PEAKS,
+                startDate =
+                    java.time.LocalDate.of(
+                        2026,
+                        7,
+                        1,
+                    ),
+                endDate =
+                    java.time.LocalDate.of(
+                        2026,
+                        7,
+                        2,
+                    ),
+                types = emptyList(),
+            )
+
+        val exception =
+            assertThrows<IllegalStateException> {
+                activityService.syncActivities(request)
+            }
+
+        assertEquals(
+            "No ActivityRepository registered " +
+                "for platform INTERVALS",
+            exception.message,
+        )
+    }
+}

boot/src/test/kotlin/io/github/costaalex/workoutrelay/app/configuration/ConfigurationServiceTest.kt

@@ -20,6 +20,7 @@ import org.mockito.Mockito.verify
 import org.mockito.Mockito.`when`
 import org.springframework.cache.Cache
 import org.springframework.cache.CacheManager
+import org.junit.jupiter.api.assertThrows
 
 class ConfigurationServiceTest {
 
@@ -212,4 +213,74 @@ class ConfigurationServiceTest {
 
         verify(cache).clear()
     }
+
+    @Test
+    fun `should return unexpected error when configuration update fails`() {
+        val request =
+            UpdateConfigurationRequest(
+                mapOf(
+                    "intervals.api-key" to "invalid-key",
+                )
+            )
+
+        doThrow(
+            RuntimeException("Database unavailable")
+        )
+            .`when`(platformConfigurationRepository)
+            .updateConfig(request)
+
+        val errors =
+            configurationService.updateConfiguration(request)
+
+        assertEquals(
+            listOf(
+                "Intervals.icu: Database unavailable"
+            ),
+            errors,
+        )
+
+        verify(debugModeService)
+            .handleDebugMode(request.configMap)
+    }
+
+    @Test
+    fun `should return fallback error when exception has no message`() {
+        val request =
+            UpdateConfigurationRequest(
+                mapOf(
+                    "intervals.api-key" to "invalid-key",
+                )
+            )
+
+        doThrow(
+            RuntimeException()
+        )
+            .`when`(platformConfigurationRepository)
+            .updateConfig(request)
+
+        val errors =
+            configurationService.updateConfiguration(request)
+
+        assertEquals(
+            listOf(
+                "Intervals.icu: Unexpected configuration error"
+            ),
+            errors,
+        )
+
+        verify(debugModeService)
+            .handleDebugMode(request.configMap)
+    }
+
+    @Test
+    fun `should fail with clear error when platform repository is missing`() {
+        val exception =
+            assertThrows<IllegalStateException> {
+                configurationService.platformInfo(
+                    Platform.TRAINING_PEAKS
+                )
+            }
+
+        assertEquals("No PlatformInfoRepository registered for platform TRAINING_PEAKS", exception.message)
+    }
 }