upgrade(docker)

client/common-ui/src/commonMain/kotlin/at/mocode/client/data/service/PingResponse.kt

@@ -1,32 +1,6 @@
 package at.mocode.client.data.service
 
-import io.ktor.client.*
-import io.ktor.client.call.*
-import io.ktor.client.plugins.contentnegotiation.*
-import io.ktor.client.request.*
-import io.ktor.serialization.kotlinx.json.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
 import kotlinx.serialization.Serializable
 
 @Serializable
 data class PingResponse(val status: String)
-
-class PingService(private val baseUrl: String = "http://localhost:8080") {
-    private val client = HttpClient {
-        install(ContentNegotiation) {
-            json()
-        }
-    }
-
-    suspend fun ping(): Result<PingResponse> = try {
-        val response = client.get("$baseUrl/api/ping/ping").body<PingResponse>()
-        Result.success(response)
-    } catch (e: Exception) {
-        Result.failure(e)
-    }
-
-    fun pingFlow(): Flow<Result<PingResponse>> = flow {
-        emit(ping())
-    }
-}

client/common-ui/src/commonMain/kotlin/at/mocode/client/data/service/PingService.kt

@@ -0,0 +1,31 @@
+package at.mocode.client.data.service
+
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.client.request.*
+import io.ktor.serialization.kotlinx.json.*
+
+class PingService(
+    private val baseUrl: String = "http://localhost:8080",
+    private val httpClient: HttpClient = createDefaultHttpClient()
+) {
+    suspend fun ping(): Result<PingResponse> = try {
+        val response = httpClient.get("$baseUrl/api/ping/ping").body<PingResponse>()
+        Result.success(response)
+    } catch (e: Exception) {
+        Result.failure(e)
+    }
+
+    fun close() {
+        httpClient.close()
+    }
+
+    companion object {
+        fun createDefaultHttpClient(): HttpClient = HttpClient {
+            install(ContentNegotiation) {
+                json()
+            }
+        }
+    }
+}

client/common-ui/src/commonMain/kotlin/at/mocode/client/ui/App.kt

@@ -9,7 +9,9 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import at.mocode.client.ui.components.PingTestComponent
+import at.mocode.client.data.service.PingService
+import at.mocode.client.ui.viewmodel.PingViewModel
+import at.mocode.client.ui.viewmodel.PingUiState
 
 @Composable
 fun App(baseUrl: String = "http://localhost:8080") {
@@ -20,18 +22,12 @@ fun App(baseUrl: String = "http://localhost:8080") {
 
 @Composable
 fun PingScreen(baseUrl: String) {
-    val pingComponent = remember { PingTestComponent(baseUrl) }
-    var pingState by remember { mutableStateOf(pingComponent.state) }
+    val pingService = remember { PingService(baseUrl) }
+    val viewModel = remember { PingViewModel(pingService) }
 
-    LaunchedEffect(pingComponent) {
-        pingComponent.onStateChanged = { newState ->
-            pingState = newState
-        }
-    }
-
-    DisposableEffect(pingComponent) {
+    DisposableEffect(viewModel) {
         onDispose {
-            pingComponent.dispose()
+            viewModel.dispose()
         }
     }
 
@@ -45,46 +41,58 @@ fun PingScreen(baseUrl: String) {
         Text(
             text = "Ping Backend Service",
             style = MaterialTheme.typography.headlineMedium,
-            modifier = Modifier.padding(bottom = 16.dp)
+            modifier = Modifier.padding(bottom = 24.dp)
         )
 
-        when {
-            pingState.isLoading -> {
-                CircularProgressIndicator()
-                Text(
-                    text = "Testing connection...",
-                    modifier = Modifier.padding(top = 8.dp)
-                )
-            }
-            pingState.error != null -> {
-                Text(
-                    text = "Error: ${pingState.error}",
-                    color = MaterialTheme.colorScheme.error,
-                    modifier = Modifier.padding(bottom = 16.dp)
-                )
-            }
-            pingState.response != null -> {
-                Text(
-                    text = "Response: ${pingState.response?.status ?: "Unknown"}",
-                    color = if (pingState.isConnected) MaterialTheme.colorScheme.primary
-                           else MaterialTheme.colorScheme.error,
-                    modifier = Modifier.padding(bottom = 16.dp)
-                )
-                Text(
-                    text = if (pingState.isConnected) "✓ Connected" else "✗ Not Connected",
-                    color = if (pingState.isConnected) MaterialTheme.colorScheme.primary
-                           else MaterialTheme.colorScheme.error
-                )
+        // Status display area with fixed height for consistent layout
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(100.dp),
+            contentAlignment = Alignment.Center
+        ) {
+            when (val state = viewModel.uiState) {
+                is PingUiState.Initial -> {
+                    Text(
+                        text = "Klicke auf den Button, um das Backend zu testen",
+                        color = MaterialTheme.colorScheme.onSurface,
+                        style = MaterialTheme.typography.bodyLarge
+                    )
+                }
+                is PingUiState.Loading -> {
+                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                        CircularProgressIndicator()
+                        Text(
+                            text = "Pinge Backend ...",
+                            color = MaterialTheme.colorScheme.onSurface,
+                            modifier = Modifier.padding(top = 8.dp)
+                        )
+                    }
+                }
+                is PingUiState.Success -> {
+                    Text(
+                        text = "Antwort vom Backend: ${state.response.status}",
+                        color = MaterialTheme.colorScheme.primary,
+                        style = MaterialTheme.typography.bodyLarge
+                    )
+                }
+                is PingUiState.Error -> {
+                    Text(
+                        text = "Fehler: ${state.message}",
+                        color = MaterialTheme.colorScheme.error,
+                        style = MaterialTheme.typography.bodyLarge
+                    )
+                }
             }
         }
 
-        Spacer(modifier = Modifier.height(16.dp))
+        Spacer(modifier = Modifier.height(24.dp))
 
         Button(
-            onClick = { pingComponent.testConnection() },
-            enabled = !pingState.isLoading
+            onClick = { viewModel.pingBackend() },
+            enabled = viewModel.uiState !is PingUiState.Loading
         ) {
-            Text("Test Connection")
+            Text("Ping Backend")
         }
     }
 }

client/common-ui/src/commonMain/kotlin/at/mocode/client/ui/components/PingTestComponent.kt

@@ -1,57 +0,0 @@
-package at.mocode.client.ui.components
-
-import at.mocode.client.data.service.PingService
-import at.mocode.client.data.service.PingResponse
-import kotlinx.coroutines.*
-
-data class PingTestState(
-    val isLoading: Boolean = false,
-    val response: PingResponse? = null,
-    val error: String? = null,
-    val isConnected: Boolean = false
-)
-
-class PingTestComponent(baseUrl: String = "http://localhost:8080") {
-    private val pingService = PingService(baseUrl)
-    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-
-    var state: PingTestState = PingTestState()
-        private set
-
-    var onStateChanged: ((PingTestState) -> Unit)? = null
-
-    fun testConnection() {
-        updateState(state.copy(isLoading = true, error = null))
-
-        scope.launch {
-            pingService.ping()
-                .onSuccess { response ->
-                    updateState(
-                        state.copy(
-                            isLoading = false,
-                            response = response,
-                            isConnected = response.status == "pong"
-                        )
-                    )
-                }
-                .onFailure { error ->
-                    updateState(
-                        state.copy(
-                            isLoading = false,
-                            error = error.message ?: "Unbekannter Fehler",
-                            isConnected = false
-                        )
-                    )
-                }
-        }
-    }
-
-    private fun updateState(newState: PingTestState) {
-        state = newState
-        onStateChanged?.invoke(state)
-    }
-
-    fun dispose() {
-        scope.cancel()
-    }
-}

client/common-ui/src/commonMain/kotlin/at/mocode/client/ui/viewmodel/PingViewModel.kt

@@ -0,0 +1,54 @@
+package at.mocode.client.ui.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import at.mocode.client.data.service.PingService
+import at.mocode.client.data.service.PingResponse
+import kotlinx.coroutines.*
+
+/**
+ * Represents the four distinct UI states as defined in the trace-bullet-guideline.md
+ */
+sealed class PingUiState {
+    /** Initial state: neutral message, button active */
+    data object Initial : PingUiState()
+
+    /** Loading state: loading message, button disabled */
+    data object Loading : PingUiState()
+
+    /** Success state: positive response, button active */
+    data class Success(val response: PingResponse) : PingUiState()
+
+    /** Error state: clear error message, button active */
+    data class Error(val message: String) : PingUiState()
+}
+
+class PingViewModel(
+    private val pingService: PingService,
+    private val coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+) {
+    var uiState by mutableStateOf<PingUiState>(PingUiState.Initial)
+        private set
+
+    fun pingBackend() {
+        uiState = PingUiState.Loading
+
+        coroutineScope.launch {
+            pingService.ping()
+                .onSuccess { response ->
+                    uiState = PingUiState.Success(response)
+                }
+                .onFailure { error ->
+                    uiState = PingUiState.Error(
+                        error.message ?: "Unbekannter Fehler beim Verbinden mit dem Backend"
+                    )
+                }
+        }
+    }
+
+    fun dispose() {
+        coroutineScope.cancel()
+        pingService.close()
+    }
+}

client/common-ui/src/commonTest/kotlin/at/mocode/client/data/service/PingResponseTest.kt

@@ -0,0 +1,110 @@
+package at.mocode.client.data.service
+
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+class PingResponseTest {
+
+    @Test
+    fun `should create PingResponse with status`() {
+        // Given
+        val status = "pong"
+
+        // When
+        val response = PingResponse(status = status)
+
+        // Then
+        assertEquals(status, response.status)
+        assertNotNull(response)
+    }
+
+    @Test
+    fun `should serialize to JSON correctly`() {
+        // Given
+        val response = PingResponse(status = "pong")
+
+        // When
+        val json = Json.encodeToString(response)
+
+        // Then
+        assertTrue(json.contains("\"status\":\"pong\""))
+        assertTrue(json.startsWith("{"))
+        assertTrue(json.endsWith("}"))
+    }
+
+    @Test
+    fun `should deserialize from JSON correctly`() {
+        // Given
+        val json = """{"status":"pong"}"""
+
+        // When
+        val response = Json.decodeFromString<PingResponse>(json)
+
+        // Then
+        assertEquals("pong", response.status)
+    }
+
+    @Test
+    fun `should handle different status values`() {
+        // Given & When & Then
+        val responses = listOf("pong", "ok", "alive", "healthy")
+
+        responses.forEach { status ->
+            val response = PingResponse(status = status)
+            assertEquals(status, response.status)
+
+            // Test serialization roundtrip
+            val json = Json.encodeToString(response)
+            val deserialized = Json.decodeFromString<PingResponse>(json)
+            assertEquals(status, deserialized.status)
+        }
+    }
+
+    @Test
+    fun `should handle empty status`() {
+        // Given
+        val emptyStatus = ""
+
+        // When
+        val response = PingResponse(status = emptyStatus)
+
+        // Then
+        assertEquals("", response.status)
+
+        // Test serialization works with empty string
+        val json = Json.encodeToString(response)
+        val deserialized = Json.decodeFromString<PingResponse>(json)
+        assertEquals("", deserialized.status)
+    }
+
+    @Test
+    fun `should be data class with proper equals and hashCode`() {
+        // Given
+        val response1 = PingResponse("pong")
+        val response2 = PingResponse("pong")
+        val response3 = PingResponse("different")
+
+        // Then
+        assertEquals(response1, response2)
+        assertEquals(response1.hashCode(), response2.hashCode())
+        assertTrue(response1 != response3)
+    }
+
+    @Test
+    fun `should have proper toString representation`() {
+        // Given
+        val response = PingResponse("pong")
+
+        // When
+        val toString = response.toString()
+
+        // Then
+        assertTrue(toString.contains("PingResponse"))
+        assertTrue(toString.contains("pong"))
+    }
+}

client/common-ui/src/commonTest/kotlin/at/mocode/client/data/service/PingServiceTest.kt

@@ -0,0 +1,155 @@
+package at.mocode.client.data.service
+
+import io.ktor.client.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.serialization.kotlinx.json.*
+import kotlin.test.*
+
+class PingServiceTest {
+
+    @Test
+    fun `should create service with default parameters`() {
+        // When
+        val service = PingService()
+
+        // Then
+        assertNotNull(service)
+    }
+
+    @Test
+    fun `should create service with custom baseUrl`() {
+        // Given
+        val customUrl = "https://custom-api.example.com"
+
+        // When
+        val service = PingService(baseUrl = customUrl)
+
+        // Then
+        assertNotNull(service)
+        // Note: baseUrl is private, so we test indirectly through behavior
+    }
+
+    @Test
+    fun `should create default HttpClient with ContentNegotiation`() {
+        // When
+        val client = PingService.createDefaultHttpClient()
+
+        // Then
+        assertNotNull(client)
+        // Verify the client is properly configured by checking it's not null and can be closed
+        client.close()
+    }
+
+    @Test
+    fun `should create service with custom HttpClient`() {
+        // Given
+        val customClient = HttpClient {
+            install(ContentNegotiation) {
+                json()
+            }
+        }
+
+        // When
+        val service = PingService("http://localhost:8080", customClient)
+
+        // Then
+        assertNotNull(service)
+
+        // Cleanup
+        service.close()
+    }
+
+    @Test
+    fun `should close httpClient when service is closed`() {
+        // Given
+        val service = PingService()
+
+        // When & Then
+        // Verify that close() doesn't throw exceptions
+        assertDoesNotThrow { service.close() }
+    }
+
+    @Test
+    fun `should handle multiple close calls gracefully`() {
+        // Given
+        val service = PingService()
+
+        // When & Then
+        // Multiple close calls should not throw exceptions
+        assertDoesNotThrow {
+            service.close()
+            service.close()
+            service.close()
+        }
+    }
+
+    @Test
+    fun `should create companion object HttpClient`() {
+        // When
+        val client1 = PingService.createDefaultHttpClient()
+        val client2 = PingService.createDefaultHttpClient()
+
+        // Then
+        assertNotNull(client1)
+        assertNotNull(client2)
+        // Each call should create a new instance
+        assertNotSame(client1, client2)
+
+        // Cleanup
+        client1.close()
+        client2.close()
+    }
+
+    @Test
+    fun `should handle service creation with different baseUrl formats`() {
+        // Given & When & Then
+        val urls = listOf(
+            "http://localhost:8080",
+            "https://api.example.com",
+            "http://192.168.1.100:3000",
+            "https://secure.api.com:9443"
+        )
+
+        urls.forEach { url ->
+            val service = PingService(baseUrl = url)
+            assertNotNull(service, "Service should be created with URL: $url")
+            service.close()
+        }
+    }
+
+    @Test
+    fun `should handle Result wrapper for ping operations`() {
+        // Given
+        val service = PingService()
+
+        // Note: We can't easily test the actual ping() method without a mock server
+        // But we can verify the service structure is correct for Result handling
+        assertNotNull(service)
+
+        // The ping() method returns Result<PingResponse> - this is tested indirectly
+        // through the service structure validation
+        service.close()
+    }
+
+    @Test
+    fun `should properly encapsulate HttpClient lifecycle`() {
+        // Given
+        var client: HttpClient? = null
+
+        // When
+        val service = PingService()
+        // We can't access the private httpClient directly, but we can test lifecycle
+        assertNotNull(service)
+
+        // Then - Service should handle cleanup properly
+        assertDoesNotThrow { service.close() }
+    }
+
+    private fun assertDoesNotThrow(block: () -> Unit) {
+        try {
+            block()
+        } catch (e: Exception) {
+            fail("Expected no exception, but got: ${e.message}")
+        }
+    }
+}

client/common-ui/src/commonTest/kotlin/at/mocode/client/ui/viewmodel/PingViewModelTest.kt

@@ -0,0 +1,147 @@
+package at.mocode.client.ui.viewmodel
+
+import at.mocode.client.data.service.PingResponse
+import at.mocode.client.data.service.PingService
+import kotlinx.coroutines.*
+import kotlinx.coroutines.test.*
+import kotlin.test.*
+
+@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+
+class PingViewModelTest {
+
+    @Test
+    fun `should create PingUiState sealed class instances`() {
+        // When & Then
+        val initial = PingUiState.Initial
+        val loading = PingUiState.Loading
+        val success = PingUiState.Success(PingResponse("pong"))
+        val error = PingUiState.Error("Test error")
+
+        assertNotNull(initial)
+        assertNotNull(loading)
+        assertNotNull(success)
+        assertNotNull(error)
+    }
+
+    @Test
+    fun `should have correct PingUiState Success data`() {
+        // Given
+        val response = PingResponse("pong")
+
+        // When
+        val successState = PingUiState.Success(response)
+
+        // Then
+        assertEquals("pong", successState.response.status)
+    }
+
+    @Test
+    fun `should have correct PingUiState Error message`() {
+        // Given
+        val errorMessage = "Network connection failed"
+
+        // When
+        val errorState = PingUiState.Error(errorMessage)
+
+        // Then
+        assertEquals(errorMessage, errorState.message)
+    }
+
+    @Test
+    fun `should create ViewModel with initial state`() {
+        // Given
+        val pingService = PingService("http://test-server")
+        val testScope = CoroutineScope(Dispatchers.Default)
+
+        // When
+        val viewModel = PingViewModel(pingService, testScope)
+
+        // Then
+        assertTrue(viewModel.uiState is PingUiState.Initial)
+
+        // Cleanup
+        testScope.cancel()
+        pingService.close()
+    }
+
+    @Test
+    fun `should transition to Loading state when pingBackend is called`() {
+        // Given
+        val pingService = PingService("http://unreachable-server")
+        val testScope = CoroutineScope(Dispatchers.Default)
+        val viewModel = PingViewModel(pingService, testScope)
+
+        // When
+        viewModel.pingBackend()
+
+        // Then - Should immediately transition to Loading
+        assertTrue(viewModel.uiState is PingUiState.Loading)
+
+        // Cleanup
+        testScope.cancel()
+        pingService.close()
+    }
+
+    @Test
+    fun `should dispose without throwing exceptions`() {
+        // Given
+        val pingService = PingService("http://test")
+        val testScope = CoroutineScope(Dispatchers.Default)
+        val viewModel = PingViewModel(pingService, testScope)
+
+        // When & Then - Should complete without exceptions
+        assertDoesNotThrow { viewModel.dispose() }
+    }
+
+    @Test
+    fun `should preserve uiState immutability`() {
+        // Given
+        val pingService = PingService("http://test")
+        val testScope = CoroutineScope(Dispatchers.Default)
+        val viewModel = PingViewModel(pingService, testScope)
+
+        // When
+        val initialState = viewModel.uiState
+
+        // Then - uiState should be immutable (no setter accessible from outside)
+        assertTrue(initialState is PingUiState.Initial)
+        // The uiState property should be read-only from external access
+        // This is enforced by the private setter in the ViewModel
+
+        // Cleanup
+        testScope.cancel()
+        pingService.close()
+    }
+
+    @Test
+    fun `should handle different service configurations`() {
+        // Given - Different service configurations
+        val service1 = PingService("http://server1")
+        val service2 = PingService("https://server2:8443")
+        val testScope1 = CoroutineScope(Dispatchers.Default)
+        val testScope2 = CoroutineScope(Dispatchers.Default)
+
+        // When
+        val viewModel1 = PingViewModel(service1, testScope1)
+        val viewModel2 = PingViewModel(service2, testScope2)
+
+        // Then
+        assertTrue(viewModel1.uiState is PingUiState.Initial)
+        assertTrue(viewModel2.uiState is PingUiState.Initial)
+
+        // Cleanup
+        testScope1.cancel()
+        testScope2.cancel()
+        service1.close()
+        service2.close()
+    }
+
+    private fun assertDoesNotThrow(block: () -> Unit) {
+        try {
+            block()
+        } catch (e: Exception) {
+            fail("Expected no exception, but got: ${e.message}")
+        }
+    }
+}