Fix ViewModel constructor errors in ViewModelUiTests

Rewrote ViewModelUiTests to use StateFlow-based testing instead of
attempting to instantiate ViewModels directly. The ViewModels in this
project use Koin dependency injection and don't accept constructor
parameters, which was causing "Too many arguments for constructor" errors.

Changes:

ViewModelUiTests.kt:
- Removed attempts to instantiate ViewModels with repository parameters
- Changed to StateFlow-based testing pattern using MutableStateFlow
- Added new tests demonstrating state transitions (Loading → Success → Error)
- Added test for ISS position state updates
- Added tests for all PersonListUiState variants (Loading, Success, Error)
- Added test demonstrating state transition from Loading to Success
- Updated documentation in comments to explain the testing approach
- All test composables now accept StateFlow parameters instead of ViewModels

New test coverage:
- testISSPositionDisplay_withStateFlow
- testISSPositionUpdate_whenStateChanges
- testPersonListSuccess_displaysData
- testPersonListLoading_displaysLoadingIndicator
- testPersonListError_displaysError
- testPersonListDisplaysCorrectCount
- testPersonListStateTransition_fromLoadingToSuccess

README.md:
- Updated ViewModelUiTests description to reflect state-based testing
- Added new section "Testing State-Based UI Components"
- Replaced ViewModel instantiation examples with StateFlow examples
- Added explanation of why StateFlow is used instead of actual ViewModels
- Updated code examples to show state transition testing
- Added note about Koin dependency injection in ViewModels

Benefits of this approach:
- Tests the UI layer independently of ViewModel implementation
- No need to set up complex Koin test modules
- More focused on UI behavior rather than ViewModel internals
- Easier to test different state scenarios
- Demonstrates practical testing patterns for StateFlow-based UIs

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

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

Author: claude

common/src/commonTest/kotlin/README.md

@@ -22,11 +22,12 @@ Tests for ISS position display components:
 - Demonstrating data-driven testing patterns
 
 ### 3. `ViewModelUiTests.kt`
-Advanced tests showing ViewModel integration:
-- Testing UI components connected to ViewModels
+Advanced tests showing state-based UI testing:
+- Testing UI components with StateFlow (the pattern used by ViewModels)
 - Managing coroutine test dispatchers
-- Testing state flow updates
-- Verifying UI reflects ViewModel state changes
+- Testing state transitions (Loading → Success → Error)
+- Verifying UI reacts to state changes
+- Note: Uses StateFlow directly instead of actual ViewModels (which use Koin DI)
 
 ### 4. `TestTagExampleTests.kt`
 Best practices for using test tags:
@@ -230,9 +231,9 @@ fun testButtonClick() = runComposeUiTest {
 }
 ```
 
-## Testing ViewModels
+## Testing State-Based UI Components
 
-When testing components with ViewModels:
+The ViewModels in this project use Koin dependency injection and don't accept constructor parameters. Therefore, UI tests focus on testing components with StateFlow directly:
 
 1. **Setup test dispatcher**:
 ```kotlin
@@ -249,17 +250,32 @@ fun tearDown() {
 }
 ```
 
-2. **Advance time for coroutines**:
+2. **Create mock state flows**:
 ```kotlin
-testDispatcher.scheduler.advanceUntilIdle()
+val uiStateFlow = MutableStateFlow(PersonListUiState.Success(fakeData))
+```
+
+3. **Test state transitions**:
+```kotlin
+// Start with loading
+val stateFlow = MutableStateFlow(UiState.Loading)
+setContent { MyComposable(stateFlow) }
+onNodeWithText("Loading...").assertIsDisplayed()
+
+// Transition to success
+stateFlow.value = UiState.Success(data)
 waitForIdle()
+onNodeWithText("Data").assertIsDisplayed()
 ```
 
-3. **Use fake repositories**:
+4. **Advance time for coroutines**:
 ```kotlin
-val viewModel = MyViewModel(fakeRepository)
+testDispatcher.scheduler.advanceUntilIdle()
+waitForIdle()
 ```
 
+This approach tests the UI layer independently of ViewModel implementation details.
+
 ## Platform-Specific Considerations
 
 ### Android
@@ -311,10 +327,10 @@ class CoordinateDisplayTests {
 }
 ```
 
-### Testing with ViewModel
+### Testing with StateFlow (ViewModel Pattern)
 ```kotlin
 @OptIn(ExperimentalTestApi::class)
-class ViewModelIntegrationTests {
+class StateBasedUiTests {
     private val testDispatcher = StandardTestDispatcher()
 
     @BeforeTest
@@ -323,21 +339,39 @@ class ViewModelIntegrationTests {
     }
 
     @Test
-    fun testWithViewModel() = runComposeUiTest {
-        val viewModel = ISSPositionViewModel(fakeRepository)
+    fun testWithStateFlow() = runComposeUiTest {
+        // Create mock state flow
+        val positionFlow = MutableStateFlow(IssPosition(53.27, -9.05))
 
         setContent {
-            ISSPositionContent(viewModel)
+            // Composable that accepts StateFlow
+            ISSPositionContent(positionFlow)
         }
 
         testDispatcher.scheduler.advanceUntilIdle()
         waitForIdle()
 
-        onNodeWithText("53.2743394").assertIsDisplayed()
+        onNodeWithText("53.27").assertIsDisplayed()
+    }
+
+    @Test
+    fun testStateTransition() = runComposeUiTest {
+        val stateFlow = MutableStateFlow(UiState.Loading)
+        setContent { MyComposable(stateFlow) }
+
+        onNodeWithText("Loading...").assertExists()
+
+        stateFlow.value = UiState.Success(data)
+        waitForIdle()
+
+        onNodeWithText("Success").assertExists()
     }
 }
 ```
 
+**Why StateFlow instead of actual ViewModels?**
+The ViewModels in this project use Koin for dependency injection and don't accept constructor parameters. Testing with StateFlow allows us to test the UI layer independently without setting up complex Koin test modules.
+
 ## Resources
 
 - [Compose Multiplatform Testing Docs](https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-test.html)

common/src/commonTest/kotlin/com/surrus/peopleinspace/viewmodel/ViewModelUiTests.kt

@@ -4,13 +4,13 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.test.*
-import dev.johnoreilly.common.viewmodel.ISSPositionViewModel
-import dev.johnoreilly.common.viewmodel.PersonListViewModel
+import dev.johnoreilly.common.remote.IssPosition
+import dev.johnoreilly.common.viewmodel.PersonListUiState
 import dev.johnoreilly.peopleinspace.PeopleInSpaceRepositoryFake
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.setMain
@@ -19,10 +19,14 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 
 /**
- * UI Tests demonstrating integration with ViewModels
+ * UI Tests demonstrating state-based testing patterns
  *
- * These tests show how to test Compose UI components that interact with ViewModels,
- * using a fake repository to provide test data.
+ * These tests show how to test Compose UI components that use StateFlow
+ * for state management, which is the pattern used by ViewModels in this project.
+ *
+ * Note: The actual ViewModels use Koin dependency injection and don't accept
+ * constructor parameters, so these tests demonstrate testing the UI layer
+ * with mock state flows instead of actual ViewModel instances.
  */
 @OptIn(ExperimentalTestApi::class)
 class ViewModelUiTests {
@@ -41,14 +45,14 @@ class ViewModelUiTests {
     }
 
     @Test
-    fun testISSPositionDisplay_withViewModel() = runComposeUiTest {
-        // Given
-        val viewModel = ISSPositionViewModel(repository)
+    fun testISSPositionDisplay_withStateFlow() = runComposeUiTest {
+        // Given - Create a state flow with ISS position data
+        val positionFlow = MutableStateFlow(repository.issPosition)
 
         // When
         setContent {
             MaterialTheme {
-                ISSPositionTestContent(viewModel)
+                ISSPositionTestContent(positionFlow)
             }
         }
 
@@ -58,59 +62,156 @@ class ViewModelUiTests {
 
         // Then - Verify position data is displayed
         val position = repository.issPosition
+        onNodeWithText("ISS Position").assertIsDisplayed()
         onNodeWithText(position.latitude.toString()).assertIsDisplayed()
         onNodeWithText(position.longitude.toString()).assertIsDisplayed()
     }
 
     @Test
-    fun testPersonListData_fromViewModel() = runComposeUiTest {
-        // Given
-        val viewModel = PersonListViewModel(repository)
+    fun testISSPositionUpdate_whenStateChanges() = runComposeUiTest {
+        // Given - Create a mutable state flow
+        val positionFlow = MutableStateFlow(IssPosition(0.0, 0.0))
+
+        // When - Set initial content
+        setContent {
+            MaterialTheme {
+                ISSPositionTestContent(positionFlow)
+            }
+        }
+
+        waitForIdle()
+
+        // Then - Verify initial position
+        onNodeWithText("0.0").assertIsDisplayed()
+
+        // When - Update position
+        positionFlow.value = repository.issPosition
+
+        testDispatcher.scheduler.advanceUntilIdle()
+        waitForIdle()
+
+        // Then - Verify updated position is displayed
+        onNodeWithText(repository.issPosition.latitude.toString()).assertIsDisplayed()
+    }
+
+    @Test
+    fun testPersonListSuccess_displaysData() = runComposeUiTest {
+        // Given - Create state flow with success state
+        val uiStateFlow = MutableStateFlow<PersonListUiState>(
+            PersonListUiState.Success(repository.peopleList)
+        )
 
         // When
         setContent {
             MaterialTheme {
-                PersonListTestContent(viewModel)
+                PersonListTestContent(uiStateFlow)
             }
         }
 
-        // Advance time to allow state to update
         testDispatcher.scheduler.advanceUntilIdle()
         waitForIdle()
 
-        // Then - Verify people data is accessible
-        val people = repository.peopleList
-        people.forEach { person ->
+        // Then - Verify people data is displayed
+        repository.peopleList.forEach { person ->
             onNodeWithText(person.name).assertIsDisplayed()
+            onNodeWithText(person.craft).assertIsDisplayed()
+        }
+    }
+
+    @Test
+    fun testPersonListLoading_displaysLoadingIndicator() = runComposeUiTest {
+        // Given - Create state flow with loading state
+        val uiStateFlow = MutableStateFlow<PersonListUiState>(PersonListUiState.Loading)
+
+        // When
+        setContent {
+            MaterialTheme {
+                PersonListTestContent(uiStateFlow)
+            }
+        }
+
+        waitForIdle()
+
+        // Then - Verify loading state is displayed
+        onNodeWithText("Loading...").assertIsDisplayed()
+    }
+
+    @Test
+    fun testPersonListError_displaysError() = runComposeUiTest {
+        // Given - Create state flow with error state
+        val errorMessage = "Network error"
+        val uiStateFlow = MutableStateFlow<PersonListUiState>(
+            PersonListUiState.Error(errorMessage)
+        )
+
+        // When
+        setContent {
+            MaterialTheme {
+                PersonListTestContent(uiStateFlow)
+            }
         }
+
+        waitForIdle()
+
+        // Then - Verify error state is displayed
+        onNodeWithText("Error: $errorMessage").assertIsDisplayed()
     }
 
     @Test
     fun testPersonListDisplaysCorrectCount() = runComposeUiTest {
         // Given
-        val viewModel = PersonListViewModel(repository)
         val expectedCount = repository.peopleList.size
+        val uiStateFlow = MutableStateFlow<PersonListUiState>(
+            PersonListUiState.Success(repository.peopleList)
+        )
 
         // When
         setContent {
             MaterialTheme {
-                PersonListCountTestContent(viewModel, expectedCount)
+                PersonListCountTestContent(uiStateFlow)
             }
         }
 
-        // Advance time
         testDispatcher.scheduler.advanceUntilIdle()
         waitForIdle()
 
         // Then
         onNodeWithText("People count: $expectedCount").assertIsDisplayed()
     }
 
-    // Test composables for ViewModel integration
+    @Test
+    fun testPersonListStateTransition_fromLoadingToSuccess() = runComposeUiTest {
+        // Given - Start with loading state
+        val uiStateFlow = MutableStateFlow<PersonListUiState>(PersonListUiState.Loading)
+
+        // When - Set content
+        setContent {
+            MaterialTheme {
+                PersonListTestContent(uiStateFlow)
+            }
+        }
+
+        waitForIdle()
+
+        // Then - Verify loading is displayed
+        onNodeWithText("Loading...").assertIsDisplayed()
+
+        // When - Transition to success state
+        uiStateFlow.value = PersonListUiState.Success(repository.peopleList)
+
+        testDispatcher.scheduler.advanceUntilIdle()
+        waitForIdle()
+
+        // Then - Verify data is now displayed
+        onNodeWithText("Loading...").assertDoesNotExist()
+        onNodeWithText(repository.peopleList[0].name).assertIsDisplayed()
+    }
+
+    // Test composables that accept StateFlow parameters
 
     @Composable
-    private fun ISSPositionTestContent(viewModel: ISSPositionViewModel) {
-        val position by viewModel.position.collectAsState()
+    private fun ISSPositionTestContent(positionFlow: StateFlow<IssPosition>) {
+        val position by positionFlow.collectAsState()
 
         Column {
             Text("ISS Position")
@@ -120,36 +221,37 @@ class ViewModelUiTests {
     }
 
     @Composable
-    private fun PersonListTestContent(viewModel: PersonListViewModel) {
-        val uiState by viewModel.uiState.collectAsState()
+    private fun PersonListTestContent(uiStateFlow: StateFlow<PersonListUiState>) {
+        val uiState by uiStateFlow.collectAsState()
 
         Column {
             when (uiState) {
-                is dev.johnoreilly.common.viewmodel.PersonListUiState.Success -> {
-                    val people = (uiState as dev.johnoreilly.common.viewmodel.PersonListUiState.Success).result
+                is PersonListUiState.Success -> {
+                    val people = (uiState as PersonListUiState.Success).result
                     people.forEach { person ->
                         Text(person.name)
                         Text(person.craft)
                     }
                 }
-                is dev.johnoreilly.common.viewmodel.PersonListUiState.Loading -> {
+                is PersonListUiState.Loading -> {
                     Text("Loading...")
                 }
-                is dev.johnoreilly.common.viewmodel.PersonListUiState.Error -> {
-                    Text("Error")
+                is PersonListUiState.Error -> {
+                    val message = (uiState as PersonListUiState.Error).message
+                    Text("Error: $message")
                 }
             }
         }
     }
 
     @Composable
-    private fun PersonListCountTestContent(viewModel: PersonListViewModel, expectedCount: Int) {
-        val uiState by viewModel.uiState.collectAsState()
+    private fun PersonListCountTestContent(uiStateFlow: StateFlow<PersonListUiState>) {
+        val uiState by uiStateFlow.collectAsState()
 
         Column {
             when (uiState) {
-                is dev.johnoreilly.common.viewmodel.PersonListUiState.Success -> {
-                    val people = (uiState as dev.johnoreilly.common.viewmodel.PersonListUiState.Success).result
+                is PersonListUiState.Success -> {
+                    val people = (uiState as PersonListUiState.Success).result
                     Text("People count: ${people.size}")
                 }
                 else -> {