feat(proposals): ask the quiet members again from the row

The offer the signing screen already makes, reached from the list. A
coordinator whose room has stalled should not have to open each proposal in
turn to find the button, and filtering to "being signed" now puts every stalled
one in front of them at once.

It is on the row and not on the chip, which is where it was asked for, for
three reasons. A chip is a selection control, and giving it a second action
would make the control that publishes the one you cannot undo. A chip stands
for several proposals while `resend` takes one session, so a chip-level button
means resending all of them -- and the manager caps itself at two messages per
resend precisely because "publishing in bursts is what the skipped-keys bug
feeds on", which three proposals at six messages would re-create. And the offer
is the coordinator's alone and only exists while somebody owes, so on a chip
standing for a mixed set it would be enabled for proposals it cannot act on.

It is called "ask again" rather than "re-broadcast" for the same reason the
list calls a review a review: somebody who found the button on the signing
screen and then found this one should not have to work out that two labels are
one button.

Whether to offer it is asked of `membersOwing`, not derived from the signature
count. Past the nonces a signer who refused has answered and is owed nothing
while the count is still short by one, so a row reading `have < need` would
offer to knock on a door that has already been shut. That is one query per row
and the only one on this screen, so it is asked for as few rows as possible:
not ours to send, nothing to send, and already ended all answer without
touching the database. An ended session is left out although the manager would
take it -- re-sending a completed one delivers the signature to a member who
never applied it, which is worth a button on the one proposal's screen rather
than a query per row on a list that only grows. The signing screen still offers
it.

Guarded per session rather than by one flag for the screen, because these rooms
have several proposals open at once and a coordinator working down the list
should not be locked out of the second by the first still publishing. The
cooldown disables rather than hides, as it does on the signing screen: a
control that vanishes after a tap reads as one that failed.

1396 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Kgothatso NgakoandClaude Opus 5 committed 2026-10-08 15:45:58 -05:00
1 parent 1f82d66f57
commit 4330d718be
6 files changed
+754 -22

No files matched your search

@@ -3,7 +3,10 @@ package to.curare.compose.ui.composable
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
@@ -11,6 +14,7 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.rememberScrollState
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Campaign
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.ChevronRight
import androidx.compose.material.icons.filled.Draw
@@ -22,6 +26,7 @@ import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.TextButton
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.ListItemDefaults
@@ -32,6 +37,7 @@ import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
@@ -59,6 +65,11 @@ import to.curare.compose.ui.theme.spacing
import curare.composeapp.generated.resources.Res
import org.jetbrains.compose.resources.stringResource
import curare.composeapp.generated.resources.abandoned
import curare.composeapp.generated.resources.everyone_has_signed_this_session
import curare.composeapp.generated.resources.asked_again_to_sign
import curare.composeapp.generated.resources.asked_again_recently
import curare.composeapp.generated.resources.asked_again
import curare.composeapp.generated.resources.ask_again
import curare.composeapp.generated.resources.you_declined
import curare.composeapp.generated.resources.you_are_signing
import curare.composeapp.generated.resources.you_agreed
@@ -91,7 +102,9 @@ import to.curare.compose.ui.composable.widgets.ErrorState
import to.curare.compose.ui.composable.widgets.LoadingDataIndicator
import to.curare.compose.ui.composable.widgets.LocalSnackbarHostState
import to.curare.compose.ui.composable.widgets.ScreenStateTransition
import to.curare.compose.ui.composable.widgets.Decorative
import to.curare.compose.ui.composable.widgets.NavigateBackButton
import to.curare.compose.ui.composable.widgets.rememberNotifier
import to.curare.compose.ui.theme.readableContent
import to.curare.compose.ui.theme.ConformancePreviews
@@ -168,6 +181,32 @@ fun ProposalListScreen(
)
is ProposalListUIState.Loaded -> {
// Read above the handlers, because `rememberNotifier` and
// `stringResource` are composable and an onClick is not. The
// notifier takes this screen's scope on purpose: a resend is
// often the last thing a coordinator does before leaving.
val notify = rememberNotifier(rememberCoroutineScope())
val asked = stringResource(Res.string.asked_again)
val askedToSign = stringResource(Res.string.asked_again_to_sign)
val nobodyLeft = stringResource(Res.string.everyone_has_signed_this_session)
val askAgain: (ProposalListUIState.Proposal) -> Unit = { proposal ->
val signing = proposal.state == ProposalState.BEING_SIGNED
proposalListViewModel.askAgain(proposal.session.id) { sent ->
notify(
when {
sent && signing -> askedToSign
sent -> asked
// Nothing went out. The row cannot tell a
// cooldown from an empty queue, so it says
// the one the button is only offered under.
else -> nobodyLeft
}
)
}
}
val open: (ProposalListUIState.Proposal) -> Unit = { proposal ->
onNavigateToRoute.invoke(
FrostSigningRoute(
@@ -200,6 +239,8 @@ fun ProposalListScreen(
ProposalList(
state = state,
onOpen = open,
onAskAgain = askAgain,
isAsking = proposalListViewModel::isAsking,
modifier = Modifier.weight(1f)
)
}
@@ -224,6 +265,8 @@ fun ProposalListScreen(
private fun ProposalList(
state: ProposalListUIState.Loaded,
onOpen: (ProposalListUIState.Proposal) -> Unit,
onAskAgain: (ProposalListUIState.Proposal) -> Unit,
isAsking: (String) -> Boolean,
modifier: Modifier = Modifier,
) {
// Said rather than defaulted, because five different absences used to say one
@@ -259,7 +302,12 @@ private fun ProposalList(
) {
if (state.filter != ProposalFilter.ALL) {
items(items = state.visible, key = { it.session.id }) { proposal ->
ProposalCard(proposal = proposal, onClick = { onOpen(proposal) })
ProposalCard(
proposal = proposal,
onClick = { onOpen(proposal) },
onAskAgain = { onAskAgain(proposal) },
asking = isAsking(proposal.session.id)
)
}
return@LazyColumn
@@ -278,7 +326,12 @@ private fun ProposalList(
items = state.waitingForYou,
key = { it.session.id }
) { proposal ->
ProposalCard(proposal = proposal, onClick = { onOpen(proposal) })
ProposalCard(
proposal = proposal,
onClick = { onOpen(proposal) },
onAskAgain = { onAskAgain(proposal) },
asking = isAsking(proposal.session.id)
)
}
}
@@ -299,7 +352,12 @@ private fun ProposalList(
items = state.rest,
key = { it.session.id }
) { proposal ->
ProposalCard(proposal = proposal, onClick = { onOpen(proposal) })
ProposalCard(
proposal = proposal,
onClick = { onOpen(proposal) },
onAskAgain = { onAskAgain(proposal) },
asking = isAsking(proposal.session.id)
)
}
}
}
@@ -381,6 +439,8 @@ private fun labelOf(filter: ProposalFilter): String = when (filter) {
private fun ProposalCard(
proposal: ProposalListUIState.Proposal,
onClick: () -> Unit,
onAskAgain: (() -> Unit)? = null,
asking: Boolean = false,
) {
val lead = proposal.signs.firstOrNull()
@@ -529,12 +589,64 @@ private fun ProposalCard(
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
if (onAskAgain != null && proposal.canAskAgain) {
AskAgainButton(
proposal = proposal,
asking = asking,
onAskAgain = onAskAgain
)
}
}
}
)
}
}
/**
* Asks the members a proposal is still waiting on to take another look.
*
* The same offer the signing screen makes, and deliberately the same words: a
* coordinator who went looking for it there and found it here should not have
* to work out that "re-broadcast" and "ask again" are one button. What the list
* adds is reach -- the one proposal that has stalled is found by filtering to
* it, rather than by opening each in turn.
*
* Disabled rather than hidden while the cooldown runs. A control that vanishes
* after a tap reads as one that failed, and what happened is that it worked.
*/
@Composable
private fun AskAgainButton(
proposal: ProposalListUIState.Proposal,
asking: Boolean,
onAskAgain: () -> Unit,
) {
val waiting = proposal.askAgainAt != null
Column(verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.space25)) {
if (waiting) {
Text(
text = stringResource(Res.string.asked_again_recently),
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
TextButton(
enabled = !waiting && !asking,
onClick = onAskAgain,
contentPadding = PaddingValues(
horizontal = MaterialTheme.spacing.compactPadding,
vertical = MaterialTheme.spacing.space25,
)
) {
Icon(Icons.Default.Campaign, contentDescription = Decorative)
Spacer(modifier = Modifier.width(MaterialTheme.spacing.itemGap))
Text(stringResource(Res.string.ask_again))
}
}
}
/**
* Who the reader is in this proposal, in a line.
*
@@ -2,6 +2,7 @@ package to.curare.compose.ui.view.model
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.mutableStateSetOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
@@ -17,6 +18,7 @@ import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.launch
import to.curare.compose.database.model.intermdiate.FrostSignerTally
import to.curare.compose.database.model.intermdiate.LocalFrostSigningSession
import to.curare.compose.database.model.types.FrostSigningStage
import to.curare.compose.extensions.shortened
import to.curare.compose.managers.FrostSigningManager
import to.curare.compose.nostr.frost.FrostSigningEvents
@@ -61,6 +63,12 @@ class ProposalListViewModel(
*/
private var filter: ProposalFilter = initialFilter
/**
* The sessions whose "ask again" is in flight, so a second tap on one row
* does not publish twice while the first is still going out.
*/
private val pending = mutableStateSetOf<String>()
private val logger = Logger.withTag(TAG)
init {
@@ -135,7 +143,7 @@ class ProposalListViewModel(
* worked out here, so the list and the signing screen cannot disagree about
* which proposals still have a decision in them.
*/
private fun asProposal(
private suspend fun asProposal(
local: LocalFrostSigningSession,
tallies: List<FrostSignerTally>,
): ProposalListUIState.Proposal {
@@ -157,10 +165,72 @@ class ProposalListViewModel(
unreadable = items.size - events.size,
awaitsYou = FrostSigningManager.isAwaitingApproval(local.session, items),
noncesOffered = counted(FrostSigningEvents.NONCE),
partialSignatures = counted(FrostSigningEvents.PARTIAL_SIGNATURE)
partialSignatures = counted(FrostSigningEvents.PARTIAL_SIGNATURE),
owing = owingFor(local)
)
}
/**
* How many members a session is still waiting on, when asking them again is
* this device's to offer.
*
* A query per row, and the only one on this screen -- so it is asked for as
* few rows as possible. Not ours to send, nothing to send, or already ended:
* all three answer null without touching the database.
*
* An ended session is left out although `FrostSigningManager.resend` would
* take it: a completed one can be re-sent to deliver the signature to a
* member who never applied it, and that is worth a button on the one
* proposal's screen rather than on every row of a list that only grows. The
* signing screen still offers it.
*/
private suspend fun owingFor(local: LocalFrostSigningSession): Int? {
val session = local.session
if (!session.isCoordinator() || local.items.isEmpty()) return null
return when (session.stage) {
FrostSigningStage.COLLECTING_NONCES,
FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES ->
frostSigningRepository.membersOwing(session).size
FrostSigningStage.COMPLETE, FrostSigningStage.FAILED -> null
}
}
/**
* Asks the members a proposal is still waiting on to take another look.
*
* Guarded per session rather than by one flag for the screen, because the
* rooms this screen is for have several proposals open at once and a
* coordinator working down the list should not be locked out of the second
* by the first still publishing.
*
* [onResult] is told whether anything went out. `resend` answers false for
* a cooldown that has not run out, a session waiting on nobody and a stage
* that cannot be resent, and the row that offered the button has no way to
* know which -- so what it says afterwards comes from here.
*/
fun askAgain(sessionId: String, onResult: (sent: Boolean) -> Unit) {
val state = proposalListUIState as? ProposalListUIState.Loaded ?: return
if (!pending.add(sessionId)) return
viewModelScope.launch(Dispatchers.IO) {
val sent = frostSigningRepository.resend(
localChatRoom = state.localChatRoom,
sessionId = sessionId
)
pending.remove(sessionId)
viewModelScope.launch(Dispatchers.Main) { onResult.invoke(sent) }
}
}
/** Whether an ask for this session is still in flight. */
fun isAsking(sessionId: String): Boolean = sessionId in pending
companion object {
private const val TAG = "ProposalListViewModel"
@@ -1,8 +1,11 @@
package to.curare.compose.ui.view.state
import kotlin.time.Clock
import kotlin.time.Instant
import to.curare.compose.database.model.FrostSigningSession
import to.curare.compose.database.model.intermdiate.LocalChatRoom
import to.curare.compose.database.model.types.FrostSigningStage
import to.curare.compose.managers.FrostSigningManager
import to.curare.compose.text.ProposedEvent
sealed interface ProposalListUIState {
@@ -104,6 +107,24 @@ sealed interface ProposalListUIState {
*/
val noncesOffered: Int = 0,
val partialSignatures: Int = 0,
/**
* How many share holders the session is still waiting on, or null when
* asking them again is not this device's to offer.
*
* Asked of `FrostSigningManager.membersOwing` rather than worked out
* from the counts above, because the two are not the same question and
* the difference is a button that does nothing. Past the nonces a signer
* who refused has answered and is owed nothing, while the signature
* count is still short by one -- so a row reading `have < need` would
* offer to knock on a door that has already been shut.
*
* Null rather than zero for a session this device did not propose: a
* resend from anybody else would have a member who was missing the
* session believe the resender coordinates. Zero means it is ours to
* send and there is nobody left to send it to.
*/
val owing: Int? = null,
) {
/** The batch's size, readable or not. */
val eventCount: Int get() = signs.size + unreadable
@@ -172,6 +193,30 @@ sealed interface ProposalListUIState {
FrostSigningStage.COMPLETE, FrostSigningStage.FAILED -> null
}
/**
* Whether to offer asking the quiet members to take another look.
*
* The same offer the signing screen makes, reached from the row rather
* than from a tap into it -- a coordinator scanning a list for the one
* that has stalled should not have to open each to find the button. It
* is offered only when there is somebody to ask, because a control that
* publishes nothing is worse than no control.
*/
val canAskAgain: Boolean get() = (owing ?: 0) > 0
/**
* When the next ask may go out, or null when one may go out now.
*
* Read at composition rather than ticked, exactly as the signing screen
* reads it. The cooldown is five minutes and every message the room
* exchanges recomposes this screen, so a button left disabled a little
* past its time is the worst this costs -- and that is the safe
* direction for a control that publishes.
*/
val askAgainAt: Instant? get() = session.resentAt
?.plus(FrostSigningManager.RESEND_COOLDOWN)
?.takeIf { it > Clock.System.now() }
}
/**
@@ -0,0 +1,132 @@
package to.curare.compose.ui.view.state
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.time.Clock
import to.curare.compose.database.model.FrostSigningSession
import to.curare.compose.database.model.types.FrostSigningStage
import to.curare.compose.managers.FrostSigningManager
/**
* When a row offers to ask the quiet members again, and when it only looks like
* it could.
*
* The offer is the coordinator's and nobody else's -- `acceptProposal` takes a
* session's coordinator from the author of the proposal that opened it, so a
* resend from anybody else would have a member who was missing the session
* believe the resender coordinates, and then drop the real coordinator's signer
* set. The row expresses that as a null rather than a zero: not ours to send is
* a different fact from nobody left to send to, and only one of them could ever
* become a button.
*/
class ProposalAskAgainTest {
private val roomId = "11".repeat(32)
private val me = "a".repeat(64)
private val somebodyElse = "b".repeat(64)
private fun session(
coordinator: String = me,
stage: FrostSigningStage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
resentAt: kotlin.time.Instant? = null,
) = FrostSigningSession(
id = "session",
chatRoomId = roomId,
coordinatorPublicKey = coordinator,
userPublicKey = me,
dkgSessionId = "ceremony",
threshold = 2,
participantCount = 3,
signerId = 1,
stage = stage,
resentAt = resentAt,
)
private fun proposal(
session: FrostSigningSession = session(),
owing: Int? = null,
) = ProposalListUIState.Proposal(
session = session,
proposerName = "You",
owing = owing,
)
@Test
fun `a session waiting on somebody offers the ask`() {
assertTrue(proposal(owing = 1).canAskAgain)
assertTrue(proposal(owing = 3).canAskAgain)
}
@Test
fun `a session waiting on nobody offers nothing, because there is nobody to ask`() {
assertFalse(proposal(owing = 0).canAskAgain)
}
/**
* Null is what the view model answers for a session this device did not
* propose, and it must not read as "waiting on nobody" turning into a button
* by some later arithmetic.
*/
@Test
fun `a session that is not ours to send offers nothing`() {
assertFalse(proposal(session(coordinator = somebodyElse), owing = null).canAskAgain)
assertNull(proposal(session(coordinator = somebodyElse)).owing)
}
@Test
fun `a proposal says nothing about the cooldown until one has been sent`() {
assertNull(proposal(owing = 1).askAgainAt)
}
@Test
fun `an ask sent just now is still cooling down`() {
val justNow = proposal(session(resentAt = Clock.System.now()), owing = 1)
assertNotNull(justNow.askAgainAt, "the cooldown should still be running")
assertTrue(
justNow.canAskAgain,
"the offer stays and the button goes quiet; a control that vanishes reads as one that failed"
)
}
@Test
fun `an ask sent longer ago than the cooldown may go again`() {
val old = Clock.System.now() - FrostSigningManager.RESEND_COOLDOWN - kotlin.time.Duration.parse("1s")
assertNull(proposal(session(resentAt = old), owing = 1).askAgainAt)
}
/** The boundary belongs to the manager, so the row reads it rather than guessing. */
@Test
fun `the cooldown the row honours is the one the manager enforces`() {
val sentAt = Clock.System.now() - FrostSigningManager.RESEND_COOLDOWN / 2
val halfway = proposal(session(resentAt = sentAt), owing = 1)
assertEquals(
sentAt + FrostSigningManager.RESEND_COOLDOWN,
halfway.askAgainAt,
"the row's cooldown drifted from the manager's"
)
}
/**
* The offer does not depend on the stage here, because the view model has
* already decided which stages it asks about -- see `owingFor`. A row only
* ever receives a count for a session that could be resent.
*/
@Test
fun `a count on any stage the view model asks about becomes an offer`() {
for (stage in listOf(
FrostSigningStage.COLLECTING_NONCES,
FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
)) {
assertTrue(
proposal(session(stage = stage), owing = 1).canAskAgain,
"$stage should be askable"
)
}
}
}
@@ -7,6 +7,8 @@ import androidx.compose.ui.test.ComposeUiTest
import androidx.compose.ui.test.ExperimentalTestApi
import androidx.compose.ui.test.assertCountEquals
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertIsEnabled
import androidx.compose.ui.test.assertIsNotEnabled
import androidx.compose.ui.test.getBoundsInRoot
import androidx.compose.ui.test.onAllNodesWithText
import androidx.compose.ui.test.onNodeWithContentDescription
@@ -17,6 +19,7 @@ import androidx.compose.ui.test.runDesktopComposeUiTest
import to.curare.compose.database.model.FrostSigningSession
import to.curare.compose.database.model.types.FrostSigningStage
import to.curare.compose.repository.ChatRepository
import to.curare.compose.database.model.intermdiate.LocalChatRoom
import to.curare.compose.repository.FrostSigningRepository
import to.curare.compose.text.ProposedEvent
import to.curare.compose.ui.composable.GroupSignedWorkFixtures.activeUserPublicKey
@@ -27,6 +30,8 @@ import to.curare.compose.ui.theme.CurareTheme
import to.curare.compose.ui.view.state.ProposalFilter
import to.curare.compose.ui.view.state.ProposalListUIState
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.time.Clock
@@ -74,11 +79,14 @@ class ProposalListScreenJvmTest {
signerIds: String? = null,
nonces: Int = 0,
signatures: Int = 0,
owing: Int? = null,
resentAt: kotlin.time.Instant? = null,
) = ProposalListUIState.Proposal(
session = session.copy(
id = id,
stage = stage,
signerIds = signerIds,
resentAt = resentAt,
signApprovedAt = Clock.System.now().takeIf { approved },
),
proposerName = "Ada",
@@ -86,6 +94,7 @@ class ProposalListScreenJvmTest {
awaitsYou = awaitsYou,
noncesOffered = nonces,
partialSignatures = signatures,
owing = owing,
)
private val needsYou = proposal("needs", "New chapter", "Genesis 1", awaitsYou = true)
@@ -362,6 +371,144 @@ class ProposalListScreenJvmTest {
onAllNodesWithText("Waiting on the rest", substring = true).assertCountEquals(0)
}
// --- asking the quiet members again ---------------------------------------------
/**
* The button a coordinator came to the list for.
*
* It says what the signing screen's says, deliberately: somebody who found
* it there and then found this should not have to work out that two labels
* are one button. What the list adds is that filtering to "being signed"
* puts every stalled proposal in front of them at once, rather than one tap
* into each.
*/
@Test
fun `a stalled proposal we coordinate offers the ask, on the being signed chip`() {
val stalled = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", signatures = 1, owing = 1,
)
render(loaded(listOf(stalled, signed))) {
chip("Being signed · 1").performClick()
onNodeWithText("Genesis 4").assertIsDisplayed()
onNodeWithText("Ask again").assertIsDisplayed().assertIsEnabled()
}
}
@Test
fun `tapping it asks for that proposal and no other`() {
val stalled = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = 1,
)
val other = proposal(
"also", "New chapter", "Genesis 5",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = 1,
)
render(loaded(listOf(stalled, other))) {
onAllNodesWithText("Ask again")[0].performClick()
waitUntil { resent.isNotEmpty() }
}
assertEquals(listOf("signing"), resent)
}
/** Opening the proposal and asking again are different taps on one row. */
@Test
fun `asking again does not open the proposal`() {
var opened: Route? = null
val stalled = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = 1,
)
render(loaded(listOf(stalled)), onNavigateToRoute = { opened = it }) {
onNodeWithText("Ask again").performClick()
waitUntil { resent.isNotEmpty() }
}
assertEquals(listOf("signing"), resent)
assertNull(opened, "the card behind the button took the tap too")
}
/**
* The offer is the coordinator's and nobody else's: a resend from anybody
* else would have a member who was missing the session believe the resender
* coordinates, and then drop the real coordinator's signer set.
*/
@Test
fun `a proposal that is not ours to send offers no button`() {
val theirs = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = null,
)
render(loaded(listOf(theirs))) {
onNodeWithText("Genesis 4").assertIsDisplayed()
onAllNodesWithText("Ask again").assertCountEquals(0)
}
}
@Test
fun `a proposal waiting on nobody offers no button`() {
val settled = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = 0,
)
render(loaded(listOf(settled))) {
onAllNodesWithText("Ask again").assertCountEquals(0)
}
}
/**
* Disabled rather than hidden while the cooldown runs. A control that
* vanishes after a tap reads as one that failed, and what happened is that
* it worked -- so the button stays and says why it is quiet.
*/
@Test
fun `an ask sent just now leaves the button in place, disabled, and says why`() {
val justAsked = proposal(
"signing", "New chapter", "Genesis 4",
stage = FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES,
approved = true, signerIds = "1,2", owing = 1,
resentAt = Clock.System.now(),
)
render(loaded(listOf(justAsked))) {
onNodeWithText("Ask again").assertIsDisplayed().assertIsNotEnabled()
onNodeWithText("Asked again just now. You can ask again in a few minutes.")
.assertIsDisplayed()
}
}
/** It is offered on the earlier stage too, where the knock is for the quiet. */
@Test
fun `a proposal still short of members offers it as well`() {
val short = proposal(
"open", "New translation", "isiZulu",
approved = true, nonces = 1, owing = 2,
)
render(loaded(listOf(short))) {
onNodeWithText("Ask again").assertIsDisplayed().assertIsEnabled()
}
}
@Test
fun `a signed proposal offers nothing to ask about`() = render(loaded(listOf(signed))) {
onAllNodesWithText("Ask again").assertCountEquals(0)
}
@Test
fun `a pushed screen keeps its way back, chips or no chips`() {
render(loaded(mixed)) { onNodeWithContentDescription("Back").assertIsDisplayed() }
@@ -384,6 +531,26 @@ class ProposalListScreenJvmTest {
proposals = proposals,
)
/**
* The sessions a render asked again for, in order.
*
* Recorded through the repository the screen is given rather than through a
* callback added for the test, so what these assert is the path the app
* takes: the button, the view model's guard, and the repository call.
*/
private val resent = mutableListOf<String>()
private fun recordingRepository() =
object : FrostSigningRepository by FrostSigningRepository.NO_OP_FROST_SIGNING_REPOSITORY {
override suspend fun resend(
localChatRoom: LocalChatRoom,
sessionId: String
): Boolean {
resent += sessionId
return true
}
}
private fun render(
uiState: ProposalListUIState,
onNavigateToRoute: (Route) -> Unit = {},
@@ -399,8 +566,7 @@ class ProposalListScreenJvmTest {
chatRoomId = chatRoomId,
initialProposalListUIState = uiState,
chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY,
frostSigningRepository =
FrostSigningRepository.NO_OP_FROST_SIGNING_REPOSITORY,
frostSigningRepository = recordingRepository(),
onNavigateBack = {},
onNavigateToRoute = onNavigateToRoute,
initialFilter = initialFilter,
@@ -5,6 +5,7 @@ import com.vitorpamplona.quartz.nip01Core.core.HexKey
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
@@ -32,7 +33,9 @@ import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertIs
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.test.fail
import kotlin.time.Clock
@@ -86,6 +89,13 @@ class ProposalListViewModelJvmTest {
room.takeIf { id == chatRoomId }
}
/** Who each session is still waiting on, and which sessions were resent. */
private val owed = mutableMapOf<String, Set<HexKey>>()
private val resent = mutableListOf<String>()
/** Held open so a test can watch a resend that has not finished yet. */
private var resendGate: CompletableDeferred<Boolean>? = null
private fun frostRepository(
sessions: Flow<List<LocalFrostSigningSession>>,
tallies: Flow<List<FrostSignerTally>> = flowOf(emptyList()),
@@ -97,6 +107,14 @@ class ProposalListViewModelJvmTest {
override fun observeSignerTalliesForChatRoom(
chatRoomId: String
): Flow<List<FrostSignerTally>> = tallies
override suspend fun membersOwing(session: FrostSigningSession): Set<HexKey> =
owed[session.id].orEmpty()
override suspend fun resend(localChatRoom: LocalChatRoom, sessionId: String): Boolean {
resent += sessionId
return resendGate?.await() ?: true
}
}
private fun nonces(sessionId: String, members: Int) =
@@ -110,10 +128,11 @@ class ProposalListViewModelJvmTest {
stage: FrostSigningStage = FrostSigningStage.COLLECTING_NONCES,
approved: Boolean = false,
signerIds: String? = null,
coordinator: String = ada,
) = FrostSigningSession(
id = id,
chatRoomId = chatRoomId,
coordinatorPublicKey = ada,
coordinatorPublicKey = coordinator,
userPublicKey = bob,
dkgSessionId = "ceremony",
threshold = 2,
@@ -124,26 +143,27 @@ class ProposalListViewModelJvmTest {
signApprovedAt = Clock.System.now().takeIf { approved },
)
/** One session with one readable event in it, as the repository hands it over. */
/** One event of a session's batch, readable so the row can name it. */
private fun item(sessionId: String, itemIndex: Int) = FrostSigningItem(
sessionId = sessionId,
itemIndex = itemIndex,
unsignedEventJson = """{"id":"${"e".repeat(64)}","pubkey":"$chatRoomId",""" +
""""created_at":1700000000,"kind":1,"tags":[],"content":"a chapter","sig":""}""",
eventId = "e".repeat(64),
nonceRandom = "00".repeat(32),
)
/** One session as the repository hands it over, with [items] events in it. */
private fun local(
id: String,
stage: FrostSigningStage = FrostSigningStage.COLLECTING_NONCES,
approved: Boolean = false,
signerIds: String? = null,
coordinator: String = ada,
items: Int = 1,
) = LocalFrostSigningSession(
session = session(id, stage, approved, signerIds),
unorderedItems = listOf(
FrostSigningItem(
sessionId = id,
itemIndex = 0,
unsignedEventJson = """
{"id":"${"e".repeat(64)}","pubkey":"$chatRoomId","created_at":1700000000,
"kind":1,"tags":[],"content":"a chapter","sig":""}
""".trimIndent().replace("\n", ""),
eventId = "e".repeat(64),
nonceRandom = "00".repeat(32),
)
),
session = session(id, stage, approved, signerIds, coordinator),
unorderedItems = (0 until items).map { index -> item(id, index) },
)
/** A room with one of each state in it. */
@@ -507,6 +527,193 @@ class ProposalListViewModelJvmTest {
model.viewModelScope.cancel()
}
// --- asking the quiet members again ---------------------------------------------
/**
* The one the signing screen gates its button on, reached from the row.
*
* Not ours to send and nobody left to send to are different facts, and only
* the second could ever become a button later. The row keeps them apart as
* null against zero so no arithmetic can turn one into the other.
*/
@Test
fun `only a session this device proposed is ours to ask again for`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["mine"] = setOf(bob)
owed["theirs"] = setOf(bob)
sessions.emit(
listOf(
local("mine", approved = true, coordinator = bob),
local("theirs", approved = true, coordinator = ada),
)
)
val model = viewModel(sessions)
model.initiate()
val byId = model.awaitLoaded().proposals.associateBy { it.session.id }
// `local` builds the row as bob's device sees it -- userPublicKey is bob
// -- so the one bob coordinates is the one with an offer on it.
assertEquals(1, byId.getValue("mine").owing)
assertTrue(byId.getValue("mine").canAskAgain)
assertNull(byId.getValue("theirs").owing, "a session we do not coordinate was costed")
assertFalse(byId.getValue("theirs").canAskAgain)
model.viewModelScope.cancel()
}
@Test
fun `a session waiting on nobody is ours but has nobody to ask`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["mine"] = emptySet()
sessions.emit(listOf(local("mine", approved = true, coordinator = bob)))
val model = viewModel(sessions)
model.initiate()
val proposal = model.awaitLoaded().proposals.single()
assertEquals(0, proposal.owing, "ours to send is not the same as nothing to send")
assertFalse(proposal.canAskAgain)
model.viewModelScope.cancel()
}
/**
* An ended session is left out although the manager would resend it: a
* completed one can be re-sent to deliver the signature to a member who
* never applied it, which is worth a button on the one proposal's screen
* rather than a query per row on a list that only grows.
*/
@Test
fun `an ended session is not costed, so a growing history stays one query`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["done"] = setOf(bob)
owed["gone"] = setOf(bob)
sessions.emit(
listOf(
local("done", stage = FrostSigningStage.COMPLETE, coordinator = bob),
local("gone", stage = FrostSigningStage.FAILED, coordinator = bob),
)
)
val model = viewModel(sessions)
model.initiate()
assertTrue(model.awaitLoaded().proposals.all { it.owing == null })
model.viewModelScope.cancel()
}
/** Nothing to resend: a session whose proposal has not landed has no events to send. */
@Test
fun `a session holding no events is not offered an ask`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["empty"] = setOf(bob)
sessions.emit(listOf(local("empty", coordinator = bob, items = 0)))
val model = viewModel(sessions)
model.initiate()
assertNull(model.awaitLoaded().proposals.single().owing)
model.viewModelScope.cancel()
}
@Test
fun `asking again resends that session and says whether anything went out`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["mine"] = setOf(bob)
sessions.emit(listOf(local("mine", approved = true, coordinator = bob)))
val model = viewModel(sessions)
model.initiate()
model.awaitLoaded()
var sent: Boolean? = null
model.askAgain("mine") { sent = it }
withTimeout(5_000) { while (sent == null) delay(10) }
assertEquals(listOf("mine"), resent)
assertEquals(true, sent)
model.viewModelScope.cancel()
}
/**
* Guarded per session rather than by one flag for the screen. These rooms
* have several proposals open at once, and a coordinator working down the
* list should not be locked out of the second by the first still publishing.
*/
@Test
fun `a second tap on the same row publishes nothing, while another row still may`() =
runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["one"] = setOf(bob)
owed["two"] = setOf(bob)
sessions.emit(
listOf(
local("one", approved = true, coordinator = bob),
local("two", approved = true, coordinator = bob),
)
)
val model = viewModel(sessions)
model.initiate()
model.awaitLoaded()
val gate = CompletableDeferred<Boolean>()
resendGate = gate
model.askAgain("one") {}
withTimeout(5_000) { while (!model.isAsking("one")) delay(10) }
// The same row again, while the first is still going out.
model.askAgain("one") {}
delay(50)
assertEquals(listOf("one"), resent, "a second tap published again")
// A different row is not locked out by it.
model.askAgain("two") {}
withTimeout(5_000) { while (resent.size < 2) delay(10) }
assertEquals(listOf("one", "two"), resent)
gate.complete(true)
withTimeout(5_000) { while (model.isAsking("one")) delay(10) }
// And once it has finished, the row may be asked again.
resendGate = null
model.askAgain("one") {}
withTimeout(5_000) { while (resent.size < 3) delay(10) }
assertEquals(listOf("one", "two", "one"), resent)
model.viewModelScope.cancel()
}
@Test
fun `a resend that published nothing is reported as such`() = runBlocking {
val sessions = MutableSharedFlow<List<LocalFrostSigningSession>>(replay = 1)
owed["mine"] = setOf(bob)
sessions.emit(listOf(local("mine", approved = true, coordinator = bob)))
val model = viewModel(sessions)
model.initiate()
model.awaitLoaded()
resendGate = CompletableDeferred<Boolean>().also { it.complete(false) }
var sent: Boolean? = null
model.askAgain("mine") { sent = it }
withTimeout(5_000) { while (sent == null) delay(10) }
assertEquals(false, sent)
model.viewModelScope.cancel()
}
private fun ProposalListViewModel.loaded(): ProposalListUIState.Loaded =
assertIs<ProposalListUIState.Loaded>(proposalListUIState)
}