Add Compose Multiplatform UI tests in commonTest

This commit adds comprehensive UI tests for Compose Multiplatform components
that can run across Android, iOS, Desktop, and Web platforms.

Changes:
- Add compose.uiTest dependency to commonTest in build.gradle.kts
- Create PeopleInSpaceRepositoryFake for consistent test data
- Add ComposeMultiplatformUiTests.kt: Basic UI component tests for CoordinateDisplay
- Add ISSPositionUiTests.kt: Tests for ISS position display with realistic data
- Add ViewModelUiTests.kt: Advanced tests demonstrating ViewModel integration
- Add TestTagExampleTests.kt: Best practices for using test tags in UI tests
- Add comprehensive README.md documenting the testing approach and patterns

The tests use runComposeUiTest instead of platform-specific createComposeRule,
allowing them to run on multiple platforms. They demonstrate:
- Testing simple composables and complex UI components
- Integration with ViewModels and StateFlow
- Test tag usage and best practices
- Coroutine test dispatcher management
- Data-driven testing patterns

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: claude

common/build.gradle.kts

@@ -79,6 +79,8 @@ kotlin {
             implementation(libs.koin.test)
             implementation(libs.kotlinx.coroutines.test)
             implementation(kotlin("test"))
+            @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
+            implementation(compose.uiTest)
         }
 
         androidMain.dependencies {

common/src/commonTest/kotlin/README.md

@@ -0,0 +1,331 @@
+# Compose Multiplatform UI Tests
+
+This directory contains Compose Multiplatform UI tests that can run across multiple platforms (Android, iOS, Desktop, Web).
+
+## Overview
+
+The tests use the **Compose Multiplatform UI Testing framework** which provides a platform-agnostic way to test Compose UI components. Unlike platform-specific tests (e.g., Android's `createComposeRule()`), these tests use `runComposeUiTest` which works across all supported platforms.
+
+## Test Files
+
+### 1. `ComposeMultiplatformUiTests.kt`
+Basic UI component tests demonstrating:
+- Testing simple composables (`CoordinateDisplay`)
+- Verifying text content is displayed
+- Testing with different input values
+- Basic assertions (`assertIsDisplayed`, `assertExists`)
+
+### 2. `ISSPositionUiTests.kt`
+Tests for ISS position display components:
+- Testing with realistic data from fake repository
+- Testing edge cases (zero coordinates, negative values, extremes)
+- Demonstrating data-driven testing patterns
+
+### 3. `ViewModelUiTests.kt`
+Advanced tests showing ViewModel integration:
+- Testing UI components connected to ViewModels
+- Managing coroutine test dispatchers
+- Testing state flow updates
+- Verifying UI reflects ViewModel state changes
+
+### 4. `TestTagExampleTests.kt`
+Best practices for using test tags:
+- Finding elements by test tag
+- Testing element hierarchies
+- Combining test tags with text matching
+- Constants for test tag names
+
+### 5. `PeopleInSpaceRepositoryFake.kt`
+Test double providing consistent test data for UI tests.
+
+## Key Differences from Platform-Specific Tests
+
+### Android Tests (app module)
+```kotlin
+class MyTest {
+    @get:Rule
+    val composeTestRule = createComposeRule()
+
+    @Test
+    fun myTest() {
+        composeTestRule.setContent { /* ... */ }
+        composeTestRule.onNodeWithText("Hello").assertIsDisplayed()
+    }
+}
+```
+
+### Multiplatform Tests (common module)
+```kotlin
+class MyTest {
+    @Test
+    fun myTest() = runComposeUiTest {
+        setContent { /* ... */ }
+        onNodeWithText("Hello").assertIsDisplayed()
+    }
+}
+```
+
+## Running the Tests
+
+### Run all common tests
+```bash
+./gradlew :common:test
+```
+
+### Run tests for specific platform
+```bash
+# Android
+./gradlew :common:testDebugUnitTest
+
+# iOS (requires macOS)
+./gradlew :common:iosSimulatorArm64Test
+
+# JVM/Desktop
+./gradlew :common:jvmTest
+
+# WebAssembly
+./gradlew :common:wasmJsTest
+```
+
+### Run tests in IDE
+- IntelliJ IDEA/Android Studio: Right-click on test file or test method and select "Run"
+- Tests will run on the JVM by default when run from IDE
+- To run on specific platform, use Gradle commands
+
+## Test Structure
+
+All tests follow this pattern:
+
+```kotlin
+@Test
+fun testName() = runComposeUiTest {
+    // 1. Setup (if needed)
+    val viewModel = MyViewModel(fakeRepository)
+
+    // 2. Set content
+    setContent {
+        MaterialTheme {
+            MyComposable(viewModel)
+        }
+    }
+
+    // 3. Advance time (for async operations)
+    testDispatcher.scheduler.advanceUntilIdle()
+    waitForIdle()
+
+    // 4. Assert
+    onNodeWithText("Expected Text").assertIsDisplayed()
+}
+```
+
+## Common Test Assertions
+
+### Existence
+```kotlin
+onNodeWithTag("myTag").assertExists()
+onNodeWithTag("myTag").assertDoesNotExist()
+```
+
+### Visibility
+```kotlin
+onNodeWithText("Hello").assertIsDisplayed()
+onNodeWithText("Hidden").assertIsNotDisplayed()
+```
+
+### Text Content
+```kotlin
+onNodeWithTag("title").assertTextEquals("Hello, World!")
+onNodeWithText("Hello", substring = true).assertExists()
+```
+
+### Hierarchy
+```kotlin
+onNodeWithTag("container")
+    .onChildren()
+    .assertCountEquals(5)
+
+onNodeWithTag("list")
+    .onChildAt(0)
+    .assertTextContains("First Item")
+```
+
+### Interactions
+```kotlin
+onNodeWithTag("button").performClick()
+onNodeWithTag("textField").performTextInput("Hello")
+onNodeWithTag("scrollable").performScrollTo()
+```
+
+## Best Practices
+
+### 1. Use Test Tags
+Always add test tags to key UI elements:
+```kotlin
+LazyColumn(
+    modifier = Modifier.testTag("PersonList")
+) {
+    items(people) { person ->
+        PersonView(person, modifier = Modifier.testTag("person_${person.id}"))
+    }
+}
+```
+
+### 2. Define Test Tag Constants
+```kotlin
+object TestTags {
+    const val PERSON_LIST = "PersonList"
+    const val ISS_MAP = "ISSMap"
+    const val REFRESH_BUTTON = "RefreshButton"
+}
+```
+
+### 3. Use Fake Repositories
+Create test doubles that provide consistent, predictable data:
+```kotlin
+class PeopleInSpaceRepositoryFake : PeopleInSpaceRepositoryInterface {
+    val peopleList = listOf(/* test data */)
+    override fun fetchPeopleAsFlow() = flowOf(peopleList)
+}
+```
+
+### 4. Test State Changes
+Verify UI responds to state updates:
+```kotlin
+@Test
+fun testLoadingState() = runComposeUiTest {
+    setContent { MyScreen(uiState = UiState.Loading) }
+    onNodeWithTag("loadingIndicator").assertExists()
+}
+
+@Test
+fun testSuccessState() = runComposeUiTest {
+    setContent { MyScreen(uiState = UiState.Success(data)) }
+    onNodeWithTag("content").assertExists()
+}
+```
+
+### 5. Test User Interactions
+```kotlin
+@Test
+fun testButtonClick() = runComposeUiTest {
+    var clicked = false
+    setContent {
+        Button(onClick = { clicked = true }) {
+            Text("Click Me")
+        }
+    }
+
+    onNodeWithText("Click Me").performClick()
+    // Assert on state change
+}
+```
+
+## Testing ViewModels
+
+When testing components with ViewModels:
+
+1. **Setup test dispatcher**:
+```kotlin
+private val testDispatcher = StandardTestDispatcher()
+
+@BeforeTest
+fun setup() {
+    Dispatchers.setMain(testDispatcher)
+}
+
+@AfterTest
+fun tearDown() {
+    Dispatchers.resetMain()
+}
+```
+
+2. **Advance time for coroutines**:
+```kotlin
+testDispatcher.scheduler.advanceUntilIdle()
+waitForIdle()
+```
+
+3. **Use fake repositories**:
+```kotlin
+val viewModel = MyViewModel(fakeRepository)
+```
+
+## Platform-Specific Considerations
+
+### Android
+- Tests run on JVM by default (Robolectric)
+- Can run on emulator/device with `testDebugUnitTest`
+
+### iOS
+- Requires macOS to run
+- Uses iOS Simulator
+
+### Desktop (JVM)
+- Runs natively on JVM
+- Fastest platform for local testing
+
+### Web (WASM)
+- Requires WebAssembly setup
+- May have limitations with certain APIs
+
+## Limitations
+
+### Current Limitations of Multiplatform UI Testing:
+
+1. **Platform-specific components**: `expect/actual` composables (like `ISSMapView`) may need platform-specific tests or mock implementations
+
+2. **Some APIs**: Certain platform-specific APIs may not be available in common tests
+
+3. **Screenshots**: Screenshot testing requires platform-specific implementations
+
+### Workarounds:
+
+1. **Mock expect functions**: Create test implementations of expect functions
+2. **Test interfaces**: Test against interfaces rather than implementations
+3. **Separate platform tests**: Keep platform-specific UI tests in platform modules
+
+## Examples from Project
+
+### Testing CoordinateDisplay
+```kotlin
+@Test
+fun testCoordinateDisplay() = runComposeUiTest {
+    setContent {
+        CoordinateDisplay(label = "Latitude", value = "53.27")
+    }
+    onNodeWithText("Latitude").assertIsDisplayed()
+    onNodeWithText("53.27").assertIsDisplayed()
+}
+```
+
+### Testing with ViewModel
+```kotlin
+@Test
+fun testWithViewModel() = runComposeUiTest {
+    val viewModel = ISSPositionViewModel(fakeRepository)
+
+    setContent {
+        ISSPositionContent(viewModel)
+    }
+
+    testDispatcher.scheduler.advanceUntilIdle()
+    waitForIdle()
+
+    onNodeWithText("53.2743394").assertIsDisplayed()
+}
+```
+
+## Resources
+
+- [Compose Multiplatform Testing Docs](https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-test.html)
+- [Compose Testing Cheatsheet](https://developer.android.com/jetpack/compose/testing-cheatsheet)
+- [Testing State in Compose](https://developer.android.com/jetpack/compose/testing#test-state)
+
+## Contributing
+
+When adding new UI tests:
+1. Follow the existing naming conventions
+2. Add test tags to new composables
+3. Create test composables for complex scenarios
+4. Document any platform-specific limitations
+5. Keep tests fast and focused

common/src/commonTest/kotlin/com/surrus/peopleinspace/PeopleInSpaceRepositoryFake.kt

@@ -0,0 +1,29 @@
+package dev.johnoreilly.peopleinspace
+
+import dev.johnoreilly.common.remote.Assignment
+import dev.johnoreilly.common.remote.IssPosition
+import dev.johnoreilly.common.repository.PeopleInSpaceRepositoryInterface
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+
+class PeopleInSpaceRepositoryFake: PeopleInSpaceRepositoryInterface {
+    val peopleList = listOf(
+        Assignment("ISS", "Chris Cassidy", "https://example.com/cassidy.jpg", "American astronaut", "USA"),
+        Assignment("ISS", "Anatoly Ivanishin", "https://example.com/ivanishin.jpg", "Russian cosmonaut", "Russia"),
+        Assignment("ISS", "Ivan Vagner", "https://example.com/vagner.jpg", "Russian cosmonaut", "Russia")
+    )
+
+    val issPosition = IssPosition(53.2743394, -9.0514163)
+
+    override fun fetchPeopleAsFlow(): Flow<List<Assignment>> {
+        return flowOf(peopleList)
+    }
+
+    override fun pollISSPosition(): Flow<IssPosition> {
+        return flowOf(issPosition)
+    }
+
+    override suspend fun fetchAndStorePeople() {
+        // No-op for fake
+    }
+}