app

commit 5364a4dee745f7097f1f7fc4a96e903406a0ff28
parent 1796610a3fee2bae4d41e7f967d18a9233f06108
Author: triesap <tyson@radroots.org>
Date:   Sat,  1 Aug 2026 18:30:33 +0000

test: prove account store isolation

- reject invalid account state during store construction
- observe sequential updates through one read-only state handle
- verify independent stores never share account state
- exercise reducer behavior through synchronous dispatch

Diffstat:
M
app/desktop/src/test/kotlin/org/radroots/studio/accounts/state/AccountsStoreTest.kt
 | 
49
+++++++++++++++++++++++++++++++++++++++++++++++++

1 file changed, 49 insertions(+), 0 deletions(-)
diff --git a/app/desktop/src/test/kotlin/org/radroots/studio/accounts/state/AccountsStoreTest.kt b/app/desktop/src/test/kotlin/org/radroots/studio/accounts/state/AccountsStoreTest.kt
@@ -2,9 +2,11 @@ package org.radroots.studio.accounts.state
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import org.radroots.studio.accounts.model.AccountId
 import org.radroots.studio.accounts.model.AccountsAction
 import org.radroots.studio.accounts.model.AccountsState
+import org.radroots.studio.accounts.testAccount
 
 class AccountsStoreTest {
     @Test
@@ -23,4 +25,51 @@ class AccountsStoreTest {
         assertEquals(AccountId("account-1"), store.state.value.selectedAccountId)
         assertEquals("Farm Account", store.state.value.accounts.single().displayName)
     }
+
+    @Test
+    fun observedStateTracksSequentialDispatches() {
+        val store = AccountsStore(
+            initialState = AccountsState(),
+            reducer = AccountsReducer { AccountId("account-1") },
+        )
+        val observedState = store.state
+
+        store.dispatch(AccountsAction.EditAddDisplayName("Farm Account"))
+        assertEquals("Farm Account", observedState.value.addDraft.displayName)
+        store.dispatch(AccountsAction.EditAddServerUrl("https://farm.example.test"))
+        store.dispatch(AccountsAction.SubmitAddAccount)
+        store.dispatch(AccountsAction.LogIn(AccountId("account-1")))
+
+        assertEquals(store.state.value, observedState.value)
+        assertEquals(1, observedState.value.accounts.size)
+    }
+
+    @Test
+    fun invalidInitialStateFailsAtConstruction() {
+        assertFailsWith<IllegalArgumentException> {
+            AccountsStore(
+                initialState = AccountsState(accounts = listOf(testAccount())),
+                reducer = AccountsReducer { AccountId("unused") },
+            )
+        }
+    }
+
+    @Test
+    fun storeInstancesNeverShareState() {
+        val first = AccountsStore(
+            initialState = AccountsState(),
+            reducer = AccountsReducer { AccountId("first") },
+        )
+        val second = AccountsStore(
+            initialState = AccountsState(),
+            reducer = AccountsReducer { AccountId("second") },
+        )
+
+        first.dispatch(AccountsAction.EditAddDisplayName("First Account"))
+        first.dispatch(AccountsAction.EditAddServerUrl("https://first.example.test"))
+        first.dispatch(AccountsAction.SubmitAddAccount)
+
+        assertEquals(listOf(AccountId("first")), first.state.value.accounts.map { it.id })
+        assertEquals(AccountsState(), second.state.value)
+    }
 }