From d2a4298d256d419a54b5d0d75a6adda505a927db Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sun, 13 Sep 2026 13:31:32 +0200 Subject: [PATCH] feat(groups): broadcast every accepted entry from one button, each to where its own would go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The entries screen had one "Broadcast" under each card, and each opened `BroadcastGroupSignedEventScreen` for that one entry: a group that has accepted twenty entries into its lists sent them with twenty trips through the relay picker. This is the other button. "Broadcast all", an extended FAB in a bottom bar, sends every entry on the screen, newest first, one after another, and says under each card what its relays answered. Behind no gate, like the button under each card: sending what the group has already signed takes no share of the key. **Each entry goes where its own broadcast screen would have started.** The list that screen seeds -- `defaultRelaysFor`: the group's General write relays or the app's publish set, plus the list's own relays, minus what the group has blocked -- is what a member who reads nothing and presses the button sends to, and this button is that member with twenty entries. The group's relay lists are read into the loaded state for it; the list's relays come off the entry, which carries its schema, so the rule is handed that one schema rather than all of the group's. Nothing is shown before the press, which is the difference from the one-event screen and the reason that screen stays: a refusal is answered there, where the relay can be changed and the send tried again. **One entry at a time, on purpose.** The rows fill in top to bottom, so the member can see where the batch is; and a public relay sent twenty events in one burst answers "rate-limited" to most of them, which would make the button worse than the presses it saves. Each entry's send has the same ceiling as a single broadcast and the batch has no other, since a long list is meant to take a while. It goes to the pool directly rather than through the queue, for the reason `BroadcastGroupSignedEventViewModel` gives, and it is only as durable as the press: leaving the screen ends it where it is. **The send is shared rather than copied.** What a relay's answer becomes -- an OK, a rejection in the relay's words, a failure, or no answer when the whole send runs out of time -- was decided inside `broadcast()` on the one-event view model. It is now `sendToRelays` on that model's companion, beside `defaultRelaysFor` and `wireEventOf`, and `broadcast()` keeps only the state around it; the thirteen tests on it pass unchanged. The words for an answer moved the same way, out of the relay row and into `RelayOutcome.label()`, which both screens now use. **What the member is told.** A line above the cards -- "Sending entry 3 of 12…", then "Accepted by every relay for 11 of 12 entries." -- persistent rather than a snackbar, because it is the answer the member came for and a snackbar would be gone before the last card had been read. Under each card, "Accepted by n of m relays." in the one-event screen's words, and one line per relay that did not say OK, named with its reason, because "blocked: not on the allow list" is something a member can act on and a count of two out of three is not. An entry with nowhere to go -- everything the seed would name blocked -- is marked so rather than sent to nobody. The FAB looks disabled while a batch is out, and a second press is refused. `GroupCuratedEntriesViewModelJvmTest` pins where each entry goes, that the next waits for the last to settle, what the answers become, and the refusals; the screen test drives the button end to end and checks that each answer sits between its card and that card's own broadcast. The shared fixture entry now carries the `a` root a real entry has -- without it the seed rule could not find the list's relays, which the first run of these tests found. Verified with :composeApp:m3Audit (all budgets met), :composeApp:compileDebugKotlinAndroid and :composeApp:jvmTest (1085 tests, 7 new). Co-Authored-By: Claude Opus 5 --- .../composeResources/values/strings.xml | 6 + .../database/model/GroupSignedEvent.kt | 7 +- .../curare/compose/nostr/GroupCuratedEntry.kt | 3 +- .../BroadcastGroupSignedEventScreen.kt | 16 +- .../composable/GroupCuratedEntriesScreen.kt | 218 +++++++++++- .../ui/composable/navigation/CurareNavHost.kt | 11 +- .../composable/widgets/RelayOutcomeLabel.kt | 30 ++ .../BroadcastGroupSignedEventViewModel.kt | 188 ++++++----- .../model/GroupCuratedEntriesViewModel.kt | 167 ++++++++++ .../view/state/GroupCuratedEntriesUIState.kt | 9 + .../GroupCuratedEntriesScreenJvmTest.kt | 115 ++++++- .../ui/composable/GroupSignedWorkFixtures.kt | 9 +- .../GroupCuratedEntriesViewModelJvmTest.kt | 309 ++++++++++++++++++ 13 files changed, 983 insertions(+), 105 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/widgets/RelayOutcomeLabel.kt create mode 100644 composeApp/src/jvmTest/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModelJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 2dfe6b5e..1cdc3724 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -649,6 +649,12 @@ Accepted by %1$s of %2$s relays. Copy raw JSON Copied the raw JSON + + Broadcast all + Sending entry %1$s of %2$s… + Accepted by every relay for %1$s of %2$s entries. + No relays to send it to: every relay the group named is blocked. + %1$s · %2$s A password-protected key (ncryptsec) is not supported yet. Decrypt it in the app it came from and paste the nsec. Enter a recovery phrase or an nsec to sign in. diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/database/model/GroupSignedEvent.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/database/model/GroupSignedEvent.kt index 0f09eb33..f848c584 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/database/model/GroupSignedEvent.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/database/model/GroupSignedEvent.kt @@ -36,9 +36,10 @@ import to.curare.compose.nostr.frost.GroupKeyStateEvent * columns are `NostrEvent`'s so that what is stored is an event rather than a * summary of one, which is what makes [verifies] answerable from the row alone. * - * The one way one reaches a relay is a member sending it there by hand, from - * `BroadcastGroupSignedEventScreen`, and that path serialises the row straight - * to the pool without ever making a `NostrEvent` of it -- see + * The one way one reaches a relay is a member sending it there by hand -- from + * `BroadcastGroupSignedEventScreen`, or every accepted entry at once from the + * entries screen -- and that path serialises the row straight to the pool + * without ever making a `NostrEvent` of it -- see * `BroadcastGroupSignedEventViewModel` for why a row would be the wrong shape. * * ### The derivation path diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/nostr/GroupCuratedEntry.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/nostr/GroupCuratedEntry.kt index 7d56c270..4084e7bb 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/nostr/GroupCuratedEntry.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/nostr/GroupCuratedEntry.kt @@ -49,7 +49,8 @@ import kotlin.time.Instant * queue screen marks a suggestion curated only from a copy read back off the * list's relays, so until a member broadcasts an entry from this section the * queue still shows it waiting. The broadcast button under each card is how - * it gets there. + * it gets there, or the one at the bottom of the entries screen that sends + * all of them. */ data class GroupCuratedEntry( /** The group's statement, whole, with the signature that makes it one. */ diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/BroadcastGroupSignedEventScreen.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/BroadcastGroupSignedEventScreen.kt index 3807c147..73a3c97c 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/BroadcastGroupSignedEventScreen.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/BroadcastGroupSignedEventScreen.kt @@ -69,11 +69,6 @@ import curare.composeapp.generated.resources.copied_the_raw_json import curare.composeapp.generated.resources.copy_raw_json import curare.composeapp.generated.resources.eg_wss_relay_example_com import curare.composeapp.generated.resources.no_relays_to_broadcast_to -import curare.composeapp.generated.resources.relay_accepted -import curare.composeapp.generated.resources.relay_could_not_send -import curare.composeapp.generated.resources.relay_no_answer -import curare.composeapp.generated.resources.relay_rejected -import curare.composeapp.generated.resources.relay_sending import curare.composeapp.generated.resources.relay_url import curare.composeapp.generated.resources.relays import curare.composeapp.generated.resources.sends_the_event_exactly_as_the_group_signed_it @@ -96,6 +91,7 @@ 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.label import to.curare.compose.ui.composable.widgets.rememberNotifier import to.curare.compose.ui.composable.widgets.NavigateBackButton import to.curare.compose.ui.theme.ConformancePreviews @@ -539,15 +535,7 @@ private fun BroadcastRelayRow( outcome?.let { Text( - text = when (it) { - RelayOutcome.Sending -> stringResource(Res.string.relay_sending) - RelayOutcome.Accepted -> stringResource(Res.string.relay_accepted) - is RelayOutcome.Rejected -> - stringResource(Res.string.relay_rejected, it.reason) - is RelayOutcome.Failed -> - stringResource(Res.string.relay_could_not_send, it.reason) - RelayOutcome.NoAnswer -> stringResource(Res.string.relay_no_answer) - }, + text = it.label(), style = MaterialTheme.typography.bodySmall, color = when (it) { RelayOutcome.Accepted -> MaterialTheme.colorScheme.primary diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreen.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreen.kt index 2ebba572..29715a26 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreen.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreen.kt @@ -10,9 +10,14 @@ import androidx.compose.foundation.layout.padding import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CellTower import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material3.BottomAppBar +import androidx.compose.material3.ButtonDefaults import androidx.compose.material3.Card import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.ExtendedFloatingActionButton +import androidx.compose.material3.FloatingActionButtonDefaults import androidx.compose.material3.Icon import androidx.compose.material3.ListItem import androidx.compose.material3.MaterialTheme @@ -21,25 +26,43 @@ import androidx.compose.material3.SnackbarHost import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TopAppBar +import androidx.compose.material3.contentColorFor import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.semantics.disabled +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.style.TextOverflow import androidx.lifecycle.viewmodel.compose.viewModel import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.relay.normalizer.displayUrl import curare.composeapp.generated.resources.Res +import curare.composeapp.generated.resources.accepted_by_every_relay_for_n_of_m_entries +import curare.composeapp.generated.resources.accepted_by_n_of_m_relays +import curare.composeapp.generated.resources.broadcast_all import curare.composeapp.generated.resources.curated_entries import curare.composeapp.generated.resources.in_list +import curare.composeapp.generated.resources.no_relays_to_send_it_to +import curare.composeapp.generated.resources.relay_and_answer +import curare.composeapp.generated.resources.relay_sending +import curare.composeapp.generated.resources.sending_entry_n_of_m import curare.composeapp.generated.resources.signed_by_the_group_on import curare.composeapp.generated.resources.suggested_by import curare.composeapp.generated.resources.this_group_has_not_accepted_anything_into_a_list_yet +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.emptyFlow import org.jetbrains.compose.resources.stringResource import to.curare.compose.database.model.ChatRoom import to.curare.compose.database.model.GroupSignedEvent +import to.curare.compose.database.model.NostrEvent import to.curare.compose.database.model.intermdiate.LocalChatRoom import to.curare.compose.extensions.shortened import to.curare.compose.extensions.toFormattedTimeAndDateString +import to.curare.compose.network.dto.RelayDTO +import to.curare.compose.network.relays.EventPublishTransport +import to.curare.compose.network.relays.NostrPublishResult import to.curare.compose.nostr.GroupCuratedEntry import to.curare.compose.nostr.GroupCuratedSchema import to.curare.compose.nostr.curated.CuratedEntry @@ -59,11 +82,14 @@ import to.curare.compose.ui.composable.widgets.LocalSnackbarHostState import to.curare.compose.ui.composable.widgets.NavigateBackButton import to.curare.compose.ui.composable.widgets.ScreenStateTransition import to.curare.compose.ui.composable.widgets.buttons.BroadcastButton +import to.curare.compose.ui.composable.widgets.label import to.curare.compose.ui.theme.ConformancePreviews import to.curare.compose.ui.theme.CurareTheme import to.curare.compose.ui.theme.readableContent import to.curare.compose.ui.theme.spacing import to.curare.compose.ui.view.model.GroupCuratedEntriesViewModel +import to.curare.compose.ui.view.model.GroupCuratedEntriesViewModel.BroadcastAllProgress +import to.curare.compose.ui.view.model.GroupCuratedEntriesViewModel.EntryBroadcast import to.curare.compose.ui.view.state.GroupCuratedEntriesUIState import kotlin.time.Instant @@ -72,9 +98,16 @@ import kotlin.time.Instant * * Pushed from its row on the group's screen, which counts the entries and * nothing more. This is where they are read: one card per entry with a - * broadcast under it. No gate on either, because reading what the group - * decided takes no share of the key, and neither does repeating its signature - * to a relay. + * broadcast under it, and one button at the bottom that broadcasts all of + * them. No gate on any of it, because reading what the group decided takes + * no share of the key, and neither does repeating its signature to a relay. + * + * The two broadcasts differ in what the member sees first. The button under + * a card opens `BroadcastGroupSignedEventScreen`, where the relays are shown + * and can be changed before the send; the one at the bottom sends every + * entry straight to where that screen would have started, one after another, + * and says under each card what its relays answered. See + * `GroupCuratedEntriesViewModel.broadcastAll` for why one at a time. * * There is no way in to add one here, because an entry is accepted from the * queue it was suggested to, which is reached from its schema's card on the @@ -89,6 +122,7 @@ fun GroupCuratedEntriesScreen( initialGroupCuratedEntriesUIState: GroupCuratedEntriesUIState = GroupCuratedEntriesUIState.Loading, chatRepository: ChatRepository, + publishTransport: EventPublishTransport, onNavigateToRoute: (Route) -> Unit, onNavigateBack: () -> Unit, ) { @@ -97,6 +131,7 @@ fun GroupCuratedEntriesScreen( chatRoomId = chatRoomId, initialGroupCuratedEntriesUIState = initialGroupCuratedEntriesUIState, chatRepository = chatRepository, + publishTransport = publishTransport, ) ) @@ -119,6 +154,53 @@ fun GroupCuratedEntriesScreen( }, navigationIcon = { NavigateBackButton(onNavigateBack) } ) + }, + bottomBar = { + // Only over a list with something in it. The empty state already + // says why there is nothing to send, and a button that sends + // nothing under it would say the opposite. + val loaded = groupCuratedEntriesViewModel.groupCuratedEntriesUIState + as? GroupCuratedEntriesUIState.Loaded + + if (loaded != null && loaded.groupCuratedEntries.isNotEmpty()) { + val canSend = !groupCuratedEntriesViewModel.isActionPending.value + + // M3 gives a FAB no `enabled`, so borrow the disabled colours every + // other button in the app uses rather than inventing a shade here. + val buttonColors = ButtonDefaults.buttonColors() + + BottomAppBar( + actions = {}, + floatingActionButton = { + ExtendedFloatingActionButton( + modifier = if (canSend) { + Modifier + } else { + // Looking unavailable is not being unavailable. + Modifier.semantics { disabled() } + }, + containerColor = if (canSend) { + FloatingActionButtonDefaults.containerColor + } else { + buttonColors.disabledContainerColor + }, + contentColor = if (canSend) { + contentColorFor(FloatingActionButtonDefaults.containerColor) + } else { + buttonColors.disabledContentColor + }, + onClick = { + if (!canSend) return@ExtendedFloatingActionButton + + groupCuratedEntriesViewModel.broadcastAll() + } + ) { + Icon(Icons.Default.CellTower, contentDescription = Decorative) + Text(stringResource(Res.string.broadcast_all)) + } + } + ) + } } ) { padding -> ScreenStateTransition(groupCuratedEntriesViewModel.groupCuratedEntriesUIState) { uiState -> @@ -162,19 +244,37 @@ fun GroupCuratedEntriesScreen( ) } } else { + // The last press of "Broadcast all", summed up, above + // the cards that break it down. Persistent rather than + // a snackbar, because it is the answer the member came + // for and a snackbar would be gone before the last + // card had been read. + groupCuratedEntriesViewModel.broadcastAllProgress?.let { progress -> + item(key = "broadcast-all-progress") { + BroadcastAllProgressLine(progress = progress) + } + } + items( items = state.groupCuratedEntries, key = { accepted -> accepted.signedEvent.id } ) { accepted -> - // The card and its broadcast as one item, so the - // button stays under the entry it sends however - // the list is arranged. + // The card, what its relays answered, and its + // broadcast as one item, so all three stay under + // the entry they are about however the list is + // arranged. The answer sits above the button + // because the button is what a refusal calls for: + // it opens the screen where the relay can be + // changed and the send tried again. Column( modifier = Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally ) { GroupCuratedEntryCard(accepted = accepted) + groupCuratedEntriesViewModel.entryBroadcasts[accepted.signedEvent.id] + ?.let { EntryBroadcastLines(broadcast = it) } + BroadcastButton( onClick = { onNavigateToRoute.invoke( @@ -197,6 +297,106 @@ fun GroupCuratedEntriesScreen( } } +/** + * Where "Broadcast all" has got to: which entry is out while the batch runs, + * and how many were accepted everywhere once it is done -- in the primary + * colour when that is all of them, and the error colour when the cards below + * have a refusal to show. + */ +@Composable +private fun BroadcastAllProgressLine(progress: BroadcastAllProgress) { + Text( + text = when (progress) { + is BroadcastAllProgress.Sending -> + stringResource(Res.string.sending_entry_n_of_m, progress.entry, progress.total) + is BroadcastAllProgress.Done -> + stringResource( + Res.string.accepted_by_every_relay_for_n_of_m_entries, + progress.acceptedEverywhere, + progress.total + ) + }, + style = MaterialTheme.typography.bodyMedium, + color = when (progress) { + is BroadcastAllProgress.Sending -> MaterialTheme.colorScheme.onSurfaceVariant + is BroadcastAllProgress.Done -> if (progress.acceptedEverywhere == progress.total) { + MaterialTheme.colorScheme.primary + } else { + MaterialTheme.colorScheme.error + } + }, + textAlign = TextAlign.Center, + modifier = Modifier.fillMaxWidth() + ) +} + +/** + * What one entry's relays answered to "Broadcast all", under its card. + * + * The count first, in the words the one-event screen uses for its own; then + * one line per relay that did not say OK, in the relay's words, because + * "blocked: not on the allow list" is something a member can act on and a + * count of two out of three is not. A relay that said OK is in the count and + * nowhere else. + */ +@Composable +private fun EntryBroadcastLines(broadcast: EntryBroadcast) { + Column( + modifier = Modifier.fillMaxWidth().padding(vertical = MaterialTheme.spacing.relatedGap), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap), + horizontalAlignment = Alignment.CenterHorizontally + ) { + when (broadcast) { + EntryBroadcast.Sending -> Text( + text = stringResource(Res.string.relay_sending), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center + ) + + EntryBroadcast.NoRelays -> Text( + text = stringResource(Res.string.no_relays_to_send_it_to), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + textAlign = TextAlign.Center + ) + + is EntryBroadcast.Sent -> { + Text( + text = stringResource( + Res.string.accepted_by_n_of_m_relays, + broadcast.accepted, + broadcast.asked + ), + style = MaterialTheme.typography.bodySmall, + color = if (broadcast.isAcceptedEverywhere) { + MaterialTheme.colorScheme.primary + } else { + MaterialTheme.colorScheme.error + }, + textAlign = TextAlign.Center + ) + + broadcast.refusals.forEach { (relay, outcome) -> + Text( + text = stringResource( + Res.string.relay_and_answer, + // The host rather than the whole URL, as the + // one-event screen's rows: every relay here starts + // `wss://`. + relay.displayUrl(), + outcome.label() + ), + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.error, + textAlign = TextAlign.Center + ) + } + } + } + } +} + /** * One entry the group accepted into a list it curates, as the list's own word. * @@ -357,6 +557,12 @@ private fun GroupCuratedEntriesScreenPreview() { ) ), chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, + publishTransport = object : EventPublishTransport { + override suspend fun publishEvent( + nostrEvent: NostrEvent, + relays: Set + ): Flow = emptyFlow() + }, onNavigateToRoute = {}, onNavigateBack = {}, ) diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/navigation/CurareNavHost.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/navigation/CurareNavHost.kt index 95eeaf8d..eb6f22da 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/navigation/CurareNavHost.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/navigation/CurareNavHost.kt @@ -1245,6 +1245,10 @@ fun CurareNavHost( chatRoomId = route.chatRoomId, relayHint = route.relayHint, chatRepository = databaseChatRepository, + // The pool itself, for "Broadcast all": the same send as the + // broadcast screen's, for the same reason it does not go + // through the queue. See `BroadcastGroupSignedEventViewModel`. + publishTransport = synchronizationViewModel.relaysSocketManager, onNavigateToRoute = { actionRoute -> navController.navigate(route = actionRoute) }, @@ -1399,9 +1403,10 @@ fun CurareNavHost( relayHint = route.relayHint, signedEventId = route.signedEventId, chatRepository = databaseChatRepository, - // The one screen handed the pool itself rather than a queue - // to write to: a group-signed event must not become a - // `NostrEvent` row, and the queue hangs off one. See + // Handed the pool itself rather than a queue to write to, + // as the entries screen is for its "Broadcast all": a + // group-signed event must not become a `NostrEvent` row, and + // the queue hangs off one. See // `BroadcastGroupSignedEventViewModel`. publishTransport = synchronizationViewModel.relaysSocketManager, onNavigateBack = { diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/widgets/RelayOutcomeLabel.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/widgets/RelayOutcomeLabel.kt new file mode 100644 index 00000000..152e7cdb --- /dev/null +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/composable/widgets/RelayOutcomeLabel.kt @@ -0,0 +1,30 @@ +package to.curare.compose.ui.composable.widgets + +import androidx.compose.runtime.Composable +import curare.composeapp.generated.resources.Res +import curare.composeapp.generated.resources.relay_accepted +import curare.composeapp.generated.resources.relay_could_not_send +import curare.composeapp.generated.resources.relay_no_answer +import curare.composeapp.generated.resources.relay_rejected +import curare.composeapp.generated.resources.relay_sending +import org.jetbrains.compose.resources.stringResource +import to.curare.compose.ui.view.model.BroadcastGroupSignedEventViewModel.RelayOutcome + +/** + * One relay's answer to a broadcast, in the words both screens that show one + * use for it: the row under a relay on `BroadcastGroupSignedEventScreen`, and + * the line under an entry that "Broadcast all" sent. + * + * A rejection and a failure carry the relay's own reason, because "blocked: + * not on the allow list" is something a member can act on and a red icon is + * not. One spelling for both screens, so a relay's answer reads the same + * whichever button sent to it. + */ +@Composable +fun RelayOutcome.label(): String = when (this) { + RelayOutcome.Sending -> stringResource(Res.string.relay_sending) + RelayOutcome.Accepted -> stringResource(Res.string.relay_accepted) + is RelayOutcome.Rejected -> stringResource(Res.string.relay_rejected, reason) + is RelayOutcome.Failed -> stringResource(Res.string.relay_could_not_send, reason) + RelayOutcome.NoAnswer -> stringResource(Res.string.relay_no_answer) +} diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/BroadcastGroupSignedEventViewModel.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/BroadcastGroupSignedEventViewModel.kt index e506e620..beb3c610 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/BroadcastGroupSignedEventViewModel.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/BroadcastGroupSignedEventViewModel.kt @@ -52,6 +52,11 @@ import kotlin.time.Duration.Companion.milliseconds * event exactly as the group signed it -- the signature is the group's, so any * member holding the event can send it and no share of the key is needed. * + * The send itself, [sendToRelays], is also what the entries screen's "Broadcast + * all" uses, one entry after another and each to the relays [defaultRelaysFor] + * would have seeded here; what is this screen's is the list the member edits + * and the rows that show each relay's answer. + * * ### Why not the broadcast queue * * Everything the app publishes as itself goes through `BroadcastNostrEventRequest`, @@ -88,8 +93,6 @@ class BroadcastGroupSignedEventViewModel( ) private set - private val logger = Logger.withTag(TAG) - val isActionPending: MutableState = mutableStateOf(false) /** @@ -238,17 +241,15 @@ class BroadcastGroupSignedEventViewModel( /** * Sends [signedEvent] to every relay in the list and records what each said. * - * One call to the pool for the whole list, which opens a socket to any relay - * it does not hold and answers once per relay -- an OK, a rejection with the - * relay's reason, or the error that stopped it being asked. Each answer lands - * in [outcomes] as it arrives, so the rows fill in one by one rather than all - * at the end; a relay that has not answered when the whole thing runs out of - * time is marked so, which is different from having been refused. + * The send itself is [sendToRelays], which the entries screen's + * "Broadcast all" shares; what is this screen's is the state around it. + * Each answer lands in [outcomes] as it arrives, so the rows fill in one + * by one rather than all at the end, and [lastBroadcast] sums it up once + * every row has settled. * - * [lastBroadcast] sums it up once every row has settled. [onNoRelays] instead - * of a send to nobody: an empty list is a question rather than a mistake, and - * the pool would otherwise fall back to the *member's* relays, which is not - * what an empty list on this screen means. + * [onNoRelays] instead of a send to nobody: an empty list is a question + * rather than a mistake, and the pool would otherwise fall back to the + * *member's* relays, which is not what an empty list on this screen means. * * Returns the send, for a caller that has to wait for it, and null when * nothing was sent. @@ -272,43 +273,13 @@ class BroadcastGroupSignedEventViewModel( outcomes.clear() targets.forEach { outcomes[it] = RelayOutcome.Sending } - val wireEvent = wireEventOf(signedEvent) - return viewModelScope.launch(Dispatchers.IO) { - try { - withTimeout(BROADCAST_TIMEOUT) { - publishTransport.publishEvent( - nostrEvent = wireEvent, - relays = targets.map { RelayDTO(url = it.url, read = false, write = true) }.toSet(), - ) - // One answer per relay is all the pool ever gives, and the - // flow underneath never completes on its own. - .take(targets.size) - .collect { result -> record(targets, result) } - } - } catch (e: TimeoutCancellationException) { - // Ordinary: a relay that never answers is what the timeout is - // for. The rows still marked as sending are settled below. - logger.w("Broadcast of ${signedEvent.id} ran out of time") - } catch (e: CancellationException) { - throw e - } catch (e: Throwable) { - // The pool refused the whole call rather than one relay's part of - // it, so every row that was waiting gets the same answer. - logger.e("Broadcast of ${signedEvent.id} failed before any relay answered", e) - targets.forEach { relay -> - if (outcomes[relay] == RelayOutcome.Sending) { - outcomes[relay] = RelayOutcome.Failed(e.message ?: "Could not send") - } - } - } - - targets.forEach { relay -> - if (outcomes[relay] == RelayOutcome.Sending) outcomes[relay] = RelayOutcome.NoAnswer + val settled = sendToRelays(publishTransport, signedEvent, targets) { relay, outcome -> + outcomes[relay] = outcome } lastBroadcast = BroadcastSummary( - accepted = targets.count { outcomes[it] == RelayOutcome.Accepted }, + accepted = settled.count { it.value == RelayOutcome.Accepted }, asked = targets.size, ) @@ -316,37 +287,11 @@ class BroadcastGroupSignedEventViewModel( } } - /** - * Files one relay's answer against the row that asked it. - * - * Matched by host rather than by string, because the pool names a relay by - * the URL it first opened a socket with, and that may carry a trailing slash - * this list's spelling does not. - */ - private fun record(targets: List, result: NostrPublishResult) { - val answered = NormalizedRelayUrl(result.relayUrl).displayUrl() - val relay = targets.firstOrNull { it.displayUrl() == answered } ?: run { - logger.w("Answer from ${result.relayUrl}, which was not asked") - return - } - - val error = result.error - val ok = result.result as? NostrIncomingMessage.OkMessage - - outcomes[relay] = when { - // The pool wraps a relay's ["OK", id, false, reason] in this one - // exception type and nothing else in it, so the message is the - // relay's reason in the relay's words. - error is NostrPublishException -> RelayOutcome.Rejected(error.message ?: "Rejected") - error != null -> RelayOutcome.Failed(error.message ?: "Could not send") - ok?.success == true -> RelayOutcome.Accepted - else -> RelayOutcome.Failed("No OK from the relay") - } - } - companion object { private const val TAG = "BroadcastGroupSignedEventViewModel" + private val logger = Logger.withTag(TAG) + /** * A ceiling on the whole broadcast, past the pool's own per-relay wait, * so a socket that opens and then says nothing cannot hold the button @@ -354,6 +299,103 @@ class BroadcastGroupSignedEventViewModel( */ val BROADCAST_TIMEOUT = (RelayPool.PUBLISH_TIMEOUT * 2).milliseconds + /** + * Sends [signedEvent] to [targets] and says what each relay answered. + * + * One call to the pool for the whole list, which opens a socket to any + * relay it does not hold and answers once per relay -- an OK, a + * rejection with the relay's reason, or the error that stopped it being + * asked. Each answer goes to [onOutcome] as it arrives, so a caller + * showing rows can fill them in one by one rather than all at the end; + * a relay that has not answered when the whole thing runs out of time + * is marked so, which is different from having been refused, and one + * the pool refused to ask at all is marked failed with the pool's reason. + * + * Returns once every relay has settled, with the answers in the order + * [targets] gave them. Shared by the one-event screen and the entries + * screen's "Broadcast all", so that what a relay's answer becomes is + * decided in one place. + */ + suspend fun sendToRelays( + publishTransport: EventPublishTransport, + signedEvent: GroupSignedEvent, + targets: List, + onOutcome: (NormalizedRelayUrl, RelayOutcome) -> Unit = { _, _ -> }, + ): Map { + val outcomes = mutableMapOf() + + fun settle(relay: NormalizedRelayUrl, outcome: RelayOutcome) { + outcomes[relay] = outcome + onOutcome(relay, outcome) + } + + try { + withTimeout(BROADCAST_TIMEOUT) { + publishTransport.publishEvent( + nostrEvent = wireEventOf(signedEvent), + relays = targets.map { RelayDTO(url = it.url, read = false, write = true) }.toSet(), + ) + // One answer per relay is all the pool ever gives, and the + // flow underneath never completes on its own. + .take(targets.size) + .collect { result -> + outcomeOf(targets, result)?.let { (relay, outcome) -> settle(relay, outcome) } + } + } + } catch (e: TimeoutCancellationException) { + // Ordinary: a relay that never answers is what the timeout is + // for. The relays still unanswered are settled below. + logger.w("Broadcast of ${signedEvent.id} ran out of time") + } catch (e: CancellationException) { + throw e + } catch (e: Throwable) { + // The pool refused the whole call rather than one relay's part of + // it, so every relay that was waiting gets the same answer. + logger.e("Broadcast of ${signedEvent.id} failed before any relay answered", e) + targets.forEach { relay -> + if (relay !in outcomes) settle(relay, RelayOutcome.Failed(e.message ?: "Could not send")) + } + } + + targets.forEach { relay -> + if (relay !in outcomes) settle(relay, RelayOutcome.NoAnswer) + } + + return targets.associateWith { outcomes.getValue(it) } + } + + /** + * One relay's answer, against the relay that was asked. + * + * Matched by host rather than by string, because the pool names a relay + * by the URL it first opened a socket with, and that may carry a + * trailing slash the caller's spelling does not. Null for an answer + * from a relay nobody asked, which is logged and dropped. + */ + private fun outcomeOf( + targets: List, + result: NostrPublishResult, + ): Pair? { + val answered = NormalizedRelayUrl(result.relayUrl).displayUrl() + val relay = targets.firstOrNull { it.displayUrl() == answered } ?: run { + logger.w("Answer from ${result.relayUrl}, which was not asked") + return null + } + + val error = result.error + val ok = result.result as? NostrIncomingMessage.OkMessage + + return relay to when { + // The pool wraps a relay's ["OK", id, false, reason] in this one + // exception type and nothing else in it, so the message is the + // relay's reason in the relay's words. + error is NostrPublishException -> RelayOutcome.Rejected(error.message ?: "Rejected") + error != null -> RelayOutcome.Failed(error.message ?: "Could not send") + ok?.success == true -> RelayOutcome.Accepted + else -> RelayOutcome.Failed("No OK from the relay") + } + } + /** * The event as the pool wants it, and nothing more. * diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModel.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModel.kt index 06fb12f9..9e9653e1 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModel.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModel.kt @@ -1,6 +1,8 @@ package to.curare.compose.ui.view.model +import androidx.compose.runtime.MutableState import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.lifecycle.ViewModel @@ -8,10 +10,16 @@ import androidx.lifecycle.ViewModelProvider import androidx.lifecycle.viewModelScope import androidx.lifecycle.viewmodel.initializer import androidx.lifecycle.viewmodel.viewModelFactory +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.relay.normalizer.NormalizedRelayUrl import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.IO +import kotlinx.coroutines.Job import kotlinx.coroutines.launch +import to.curare.compose.network.relays.EventPublishTransport +import to.curare.compose.nostr.GroupCuratedEntry import to.curare.compose.repository.ChatRepository +import to.curare.compose.ui.view.model.BroadcastGroupSignedEventViewModel.RelayOutcome import to.curare.compose.ui.view.state.GroupCuratedEntriesUIState /** @@ -19,11 +27,34 @@ import to.curare.compose.ui.view.state.GroupCuratedEntriesUIState * that shows them. One read rather than a watch, for the reason * `GroupNostrProfileViewModel` gives. Nothing here asks whether this device * can sign, because nothing on the screen would change if it could. + * + * ### Broadcast all + * + * The one thing the screen does besides show: [broadcastAll] sends every + * entry, one after another, each to the relays its own broadcast screen would + * have filled in -- `defaultRelaysFor`, read against the group's relay lists + * and the entry's own schema -- and says under each card what its relays + * answered. The member sees nothing before pressing, which is the difference + * from sending one at a time: that screen exists so the relays can be read + * and changed first, and this button is for the member who has read them + * once and has twenty entries to send. The seeded list is what a member who + * reads nothing and presses the button sends to there too. + * + * One entry at a time rather than all at once, for two reasons. The rows fill + * in top to bottom, so the member can see where the batch is; and a public + * relay sent twenty events in one burst answers "rate-limited" to most of + * them, which would make the button worse than the twenty presses it saves. + * Each entry's send is bounded by the same ceiling as a single broadcast, + * and the whole batch by nothing but that, since a long list is meant to + * take a while. It goes to the pool directly rather than through the queue, + * for the reason `BroadcastGroupSignedEventViewModel` gives, and it is only + * as durable as the button press: leaving the screen ends it where it is. */ class GroupCuratedEntriesViewModel( val chatRoomId: String, initialGroupCuratedEntriesUIState: GroupCuratedEntriesUIState, val chatRepository: ChatRepository, + val publishTransport: EventPublishTransport, ): ViewModel() { var groupCuratedEntriesUIState: GroupCuratedEntriesUIState by mutableStateOf( @@ -31,6 +62,69 @@ class GroupCuratedEntriesViewModel( ) private set + val isActionPending: MutableState = mutableStateOf(false) + + /** + * How each entry's send went the last time the button was pressed, keyed + * by the signed event's id. An entry the batch has not reached yet has + * none, which is how the screen tells "not yet" from "sending". + */ + val entryBroadcasts = mutableStateMapOf() + + /** + * Where the last press has got to, or null before the first one. + * + * On the screen rather than in a snackbar, for the reason the one-event + * screen gives: it is the answer the member came for, and it should still + * be there once the cards under it have been read. Cleared when the next + * press starts. + */ + var broadcastAllProgress: BroadcastAllProgress? by mutableStateOf(null) + private set + + /** One entry's part of one press of the button. */ + sealed interface EntryBroadcast { + /** Sent, and not every relay has answered yet. */ + data object Sending : EntryBroadcast + + /** + * Not sent, because there was nowhere to send it: everything the seed + * rule would have named is on the group's blocked list. The one-event + * screen meets the same case as an empty list and a snackbar. + */ + data object NoRelays : EntryBroadcast + + /** Every relay has answered, or been given up on. */ + data class Sent(val outcomes: Map) : EntryBroadcast { + val accepted: Int get() = outcomes.count { it.value == RelayOutcome.Accepted } + + val asked: Int get() = outcomes.size + + val isAcceptedEverywhere: Boolean get() = accepted == asked + + /** + * The relays that did not say OK, with what they said instead, in + * the order they were asked. Named under the count because the + * relay's reason is what a member can act on, and a count is not. + */ + val refusals: List> + get() = outcomes.filterValues { it != RelayOutcome.Accepted }.toList() + } + } + + /** How far the last press has got, and then how it went. */ + sealed interface BroadcastAllProgress { + /** Entry [entry] of [total] is out, counting from one. */ + data class Sending(val entry: Int, val total: Int) : BroadcastAllProgress + + /** + * Every entry has been sent, and [acceptedEverywhere] of [total] were + * accepted by every relay they went to. The rest say under their own + * cards which relay refused, and why. + */ + data class Done(val acceptedEverywhere: Int, val total: Int) : BroadcastAllProgress + } + fun initiate() { viewModelScope.launch(Dispatchers.IO) { val localChatRoom = chatRepository.getChatRoomByIdentifier(chatRoomId) @@ -41,23 +135,96 @@ class GroupCuratedEntriesViewModel( GroupCuratedEntriesUIState.Loaded( localChatRoom = localChatRoom, groupCuratedEntries = chatRepository.groupCuratedEntries(chatRoomId), + relayLists = chatRepository.groupRelayLists(chatRoomId), ) } } } + /** + * Sends every entry on the screen, in the order it shows them, and records + * what each one's relays said. + * + * Returns the batch, for a caller that has to wait for it, and null when + * nothing was sent: a press while one is already out, or a screen with no + * entries on it, which has no button. + */ + fun broadcastAll(): Job? { + // Guard against double submits. A second press while the first is out + // would send every entry twice and count each answer twice. + if (isActionPending.value) return null + + val state = groupCuratedEntriesUIState as? GroupCuratedEntriesUIState.Loaded ?: return null + val entries = state.groupCuratedEntries + if (entries.isEmpty()) return null + + isActionPending.value = true + broadcastAllProgress = null + entryBroadcasts.clear() + + return viewModelScope.launch(Dispatchers.IO) { + var acceptedEverywhere = 0 + + entries.forEachIndexed { index, accepted -> + broadcastAllProgress = BroadcastAllProgress.Sending(entry = index + 1, total = entries.size) + + val sent = send(accepted, state) + entryBroadcasts[accepted.signedEvent.id] = sent + if (sent is EntryBroadcast.Sent && sent.isAcceptedEverywhere) acceptedEverywhere++ + } + + broadcastAllProgress = BroadcastAllProgress.Done( + acceptedEverywhere = acceptedEverywhere, + total = entries.size, + ) + + isActionPending.value = false + } + } + + /** + * One entry, to where its own broadcast screen would have sent it. + * + * The relays are the seed rule's, read against the group's lists and the + * entry's own schema -- an entry carries the list it is in, so the rule + * is handed that one schema rather than all of the group's. + */ + private suspend fun send( + accepted: GroupCuratedEntry, + state: GroupCuratedEntriesUIState.Loaded, + ): EntryBroadcast { + val signedEvent = accepted.signedEvent + val targets = BroadcastGroupSignedEventViewModel.defaultRelaysFor( + relayLists = state.relayLists, + kind = signedEvent.kind, + tags = signedEvent.tags, + content = signedEvent.content, + schemas = listOf(accepted.list), + ) + + if (targets.isEmpty()) return EntryBroadcast.NoRelays + + entryBroadcasts[signedEvent.id] = EntryBroadcast.Sending + + return EntryBroadcast.Sent( + BroadcastGroupSignedEventViewModel.sendToRelays(publishTransport, signedEvent, targets) + ) + } + companion object { fun factory( chatRoomId: String, initialGroupCuratedEntriesUIState: GroupCuratedEntriesUIState = GroupCuratedEntriesUIState.Loading, chatRepository: ChatRepository, + publishTransport: EventPublishTransport, ): ViewModelProvider.Factory = viewModelFactory { initializer { GroupCuratedEntriesViewModel( chatRoomId = chatRoomId, initialGroupCuratedEntriesUIState = initialGroupCuratedEntriesUIState, chatRepository = chatRepository, + publishTransport = publishTransport, ) } } diff --git a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/state/GroupCuratedEntriesUIState.kt b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/state/GroupCuratedEntriesUIState.kt index da4ec1f7..2d32b1a1 100644 --- a/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/state/GroupCuratedEntriesUIState.kt +++ b/composeApp/src/commonMain/kotlin/to/curare/compose/ui/view/state/GroupCuratedEntriesUIState.kt @@ -2,6 +2,7 @@ package to.curare.compose.ui.view.state import to.curare.compose.database.model.intermdiate.LocalChatRoom import to.curare.compose.nostr.GroupCuratedEntry +import to.curare.compose.nostr.GroupRelayList sealed interface GroupCuratedEntriesUIState { data class Loaded( @@ -16,6 +17,14 @@ sealed interface GroupCuratedEntriesUIState { * neither does repeating its signature to a relay. */ val groupCuratedEntries: List = emptyList(), + /** + * Where the group has said it lives, for "Broadcast all": each entry + * goes where its own broadcast screen would send it before the member + * changed anything, and that starts from these. See + * `BroadcastGroupSignedEventViewModel.defaultRelaysFor`; the list's + * own relays come off the entry, which carries its schema. + */ + val relayLists: List = emptyList(), ): GroupCuratedEntriesUIState data class Error( diff --git a/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreenJvmTest.kt b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreenJvmTest.kt index 9e03e537..1d931e6c 100644 --- a/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreenJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupCuratedEntriesScreenJvmTest.kt @@ -12,7 +12,19 @@ import androidx.compose.ui.test.onAllNodesWithText import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.performClick import androidx.compose.ui.test.runDesktopComposeUiTest +import com.vitorpamplona.quartz.nip01Core.relay.normalizer.RelayUrlNormalizer +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flowOf +import to.curare.compose.database.model.NostrEvent +import to.curare.compose.exceptions.NostrPublishException +import to.curare.compose.network.dto.RelayDTO +import to.curare.compose.network.relays.EventPublishTransport +import to.curare.compose.network.relays.NostrPublishResult +import to.curare.compose.network.sockets.NostrIncomingMessage import to.curare.compose.nostr.GroupCuratedEntry +import to.curare.compose.nostr.GroupRelay +import to.curare.compose.nostr.GroupRelayList +import to.curare.compose.nostr.GroupRelaySet import to.curare.compose.repository.ChatRepository import to.curare.compose.ui.composable.GroupSignedWorkFixtures.activeUserPublicKey import to.curare.compose.ui.composable.GroupSignedWorkFixtures.chatRoomId @@ -28,8 +40,8 @@ import kotlin.test.assertTrue /** * The entries the group has accepted on their own screen: one card per entry, - * most recently signed first, each with its broadcast and nothing else -- - * there is no way in to add one here. + * most recently signed first, each with its broadcast, and one button at the + * bottom that broadcasts all of them -- there is no way in to add one here. */ @OptIn(ExperimentalTestApi::class) class GroupCuratedEntriesScreenJvmTest { @@ -37,6 +49,19 @@ class GroupCuratedEntriesScreenJvmTest { private val newest = entry("The Rise and Rise of Bitcoin", 1_700_000_900) private val oldest = entry("Magic Money", 1_700_000_300, suggestedBy = null) + private val one = RelayUrlNormalizer.normalize("wss://relay.one.example") + private val two = RelayUrlNormalizer.normalize("wss://relay.two.example") + + /** A pool that answers each event as [answers] says and never opens a socket. */ + private class FakeTransport( + private val answers: (NostrEvent) -> List = { emptyList() } + ) : EventPublishTransport { + override suspend fun publishEvent( + nostrEvent: NostrEvent, + relays: Set + ): Flow = flowOf(*answers(nostrEvent).toTypedArray()) + } + @Test fun `the entries are drawn most recently signed first, one card per entry`() = render( state(entries = listOf(newest, oldest)) @@ -95,19 +120,100 @@ class GroupCuratedEntriesScreenJvmTest { .assertIsDisplayed() // An entry is accepted from the queue on its schema's card, on the - // schemas screen, so this screen has no button of its own. + // schemas screen, so this screen has no button of its own -- and + // nothing to broadcast, so no button for that either. onAllNodesWithText("Add entry").assertCountEquals(0) onAllNodesWithText("Broadcast").assertCountEquals(0) + onAllNodesWithText("Broadcast all").assertCountEquals(0) } + @Test + fun `the button at the bottom sends every entry, and each card says what its relays answered`() { + val ok = { relay: String, event: NostrEvent -> + NostrPublishResult( + result = NostrIncomingMessage.OkMessage(eventId = event.id, success = true), + relayUrl = relay, + ) + } + val transport = FakeTransport { event -> + if (event.id == newest.signedEvent.id) { + listOf(ok(two.url, event), ok(one.url, event)) + } else { + listOf( + ok(two.url, event), + NostrPublishResult( + result = NostrIncomingMessage.OkMessage( + eventId = event.id, + success = false, + message = "blocked: not on the allow list", + ), + error = NostrPublishException(message = "blocked: not on the allow list"), + relayUrl = one.url, + ), + ) + } + } + + render(state(entries = listOf(newest, oldest)), transport = transport) { + onNodeWithText("Broadcast all").performClick() + + // The sum above the cards, once the last has settled. + waitUntil(timeoutMillis = 5_000) { + onAllNodesWithText("Accepted by every relay for 1 of 2 entries.") + .fetchSemanticsNodes().isNotEmpty() + } + + // Each entry's count, and the one relay that refused named with its + // reason -- the relay that said OK is in the count and nowhere else. + onNodeWithText("Accepted by 2 of 2 relays.").assertIsDisplayed() + onNodeWithText("Accepted by 1 of 2 relays.").assertIsDisplayed() + onNodeWithText("relay.one.example · Rejected: blocked: not on the allow list") + .assertIsDisplayed() + onAllNodesWithText("relay.two.example", substring = true).assertCountEquals(0) + + // The sum above every card; each answer under its own card and + // above that card's broadcast, which is what a refusal calls for. + val sum = onNodeWithText("Accepted by every relay for 1 of 2 entries.").getBoundsInRoot().top + val firstCard = onNodeWithText("The Rise and Rise of Bitcoin").getBoundsInRoot().top + val firstAnswer = onNodeWithText("Accepted by 2 of 2 relays.").getBoundsInRoot().top + val secondCard = onNodeWithText("Magic Money").getBoundsInRoot().top + val secondAnswer = onNodeWithText("Accepted by 1 of 2 relays.").getBoundsInRoot().top + val buttons = onAllNodesWithText("Broadcast") + val firstButton = buttons[0].getBoundsInRoot().top + val secondButton = buttons[1].getBoundsInRoot().top + + assertTrue(sum < firstCard, "the sum is not above the cards") + assertTrue(firstCard < firstAnswer && firstAnswer < firstButton, "the first answer is not between its card and its broadcast") + assertTrue(firstButton < secondCard, "the second card climbed above the first's broadcast") + assertTrue(secondCard < secondAnswer && secondAnswer < secondButton, "the second answer is not between its card and its broadcast") + } + } + + /** + * A General list of [two] agreed, so each entry goes to one relay of the + * group's and one of its list's -- [one], which the fixture's schema names. + */ + private fun relayLists(): List = + GroupRelayList.allAmong(emptyList(), chatRoomId).map { list -> + if (list.set != GroupRelaySet.General) return@map list + + GroupRelayList( + set = list.set, + signedEvent = GroupSignedWorkFixtures.relaySignedEvent(list.set), + relays = listOf(GroupRelay(two)), + ) + } + private fun state(entries: List) = GroupCuratedEntriesUIState.Loaded( localChatRoom = GroupSignedWorkFixtures.localChatRoom(), - groupCuratedEntries = entries + groupCuratedEntries = entries, + relayLists = relayLists(), ) private fun render( uiState: GroupCuratedEntriesUIState, onNavigateToRoute: (Route) -> Unit = {}, + transport: EventPublishTransport = FakeTransport(), assertions: ComposeUiTest.() -> Unit ) = runDesktopComposeUiTest(width = 400, height = 2000) { setContent { @@ -120,6 +226,7 @@ class GroupCuratedEntriesScreenJvmTest { relayHint = null, initialGroupCuratedEntriesUIState = uiState, chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, + publishTransport = transport, onNavigateToRoute = onNavigateToRoute, onNavigateBack = {}, ) diff --git a/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupSignedWorkFixtures.kt b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupSignedWorkFixtures.kt index 6c60de49..a150876b 100644 --- a/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupSignedWorkFixtures.kt +++ b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/composable/GroupSignedWorkFixtures.kt @@ -185,7 +185,14 @@ internal object GroupSignedWorkFixtures { chatRoomId = chatRoomId, publicKey = chatRoomId, kind = CuratedEntryEvent.CANONICAL_KIND, - tags = arrayOf(arrayOf("d", identifier), arrayOf("title", title)), + // The root names the list, as a real entry's does: it is how + // the reading matched the entry to its schema, and how the + // broadcast finds the list's relays. + tags = arrayOf( + arrayOf("a", list.coordinate(), "", "root"), + arrayOf("d", identifier), + arrayOf("title", title) + ), content = "", signature = "f".repeat(128), createdAt = Instant.fromEpochSeconds(createdAt) diff --git a/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModelJvmTest.kt b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModelJvmTest.kt new file mode 100644 index 00000000..b51bec31 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/to/curare/compose/ui/view/model/GroupCuratedEntriesViewModelJvmTest.kt @@ -0,0 +1,309 @@ +package to.curare.compose.ui.view.model + +import com.vitorpamplona.quartz.nip01Core.relay.normalizer.NormalizedRelayUrl +import com.vitorpamplona.quartz.nip01Core.relay.normalizer.RelayUrlNormalizer +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.test.UnconfinedTestDispatcher +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.setMain +import kotlinx.coroutines.withTimeout +import to.curare.compose.database.model.NostrEvent +import to.curare.compose.exceptions.NostrPublishException +import to.curare.compose.network.dto.RelayDTO +import to.curare.compose.network.relays.EventPublishTransport +import to.curare.compose.network.relays.NostrPublishResult +import to.curare.compose.network.sockets.NostrIncomingMessage +import to.curare.compose.nostr.GroupCuratedEntry +import to.curare.compose.nostr.GroupRelay +import to.curare.compose.nostr.GroupRelayList +import to.curare.compose.nostr.GroupRelaySet +import to.curare.compose.repository.ChatRepository +import to.curare.compose.ui.composable.GroupSignedWorkFixtures +import to.curare.compose.ui.composable.GroupSignedWorkFixtures.chatRoomId +import to.curare.compose.ui.composable.GroupSignedWorkFixtures.entry +import to.curare.compose.ui.view.model.BroadcastGroupSignedEventViewModel.RelayOutcome +import to.curare.compose.ui.view.model.GroupCuratedEntriesViewModel.BroadcastAllProgress +import to.curare.compose.ui.view.model.GroupCuratedEntriesViewModel.EntryBroadcast +import to.curare.compose.ui.view.state.GroupCuratedEntriesUIState +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 + +/** + * What "Broadcast all" decides that nothing else can check. + * + * **Where each entry goes.** The same relays its own broadcast screen would + * have filled in -- the group's General list plus the list the entry is in, + * minus what the group has blocked -- because the button is the member + * trusting that seed rather than editing it, and a rule that sent to + * anywhere else would make the two buttons disagree. + * + * **One after another, in the order shown.** The transport is asked once per + * entry, and the next is not asked until the last has settled. + * + * **What the answers become.** The count under each card and the sum above + * them, with a relay that refused named against its reason, and an entry with + * nowhere to go marked so rather than sent to nobody. + */ +@OptIn(ExperimentalCoroutinesApi::class) +class GroupCuratedEntriesViewModelJvmTest { + + private val one = RelayUrlNormalizer.normalize("wss://relay.one.example") + private val two = RelayUrlNormalizer.normalize("wss://relay.two.example") + + /** + * Answers every event with [answers] and remembers each send in the order + * it was asked for. Holds every answer back until [gate] is completed, + * where a test hands one in, so a batch can be caught while it is out; + * [arrived] says when the first send has reached it. + */ + private class FakeTransport( + private val gate: CompletableDeferred? = null, + private val answers: (NostrEvent) -> List, + ) : EventPublishTransport { + val sends = mutableListOf>>() + + val arrived = CompletableDeferred() + + override suspend fun publishEvent( + nostrEvent: NostrEvent, + relays: Set + ): Flow { + sends += nostrEvent to relays + arrived.complete(Unit) + gate?.await() + return flowOf(*answers(nostrEvent).toTypedArray()) + } + } + + @BeforeTest + fun setUp() { + Dispatchers.setMain(UnconfinedTestDispatcher()) + } + + @AfterTest + fun tearDown() { + Dispatchers.resetMain() + } + + private val newest = entry("The Rise and Rise of Bitcoin", 1_700_000_900) + private val oldest = entry("Magic Money", 1_700_000_300, suggestedBy = null) + + /** + * A General list of [two] agreed, so each entry has one relay of the + * group's and one of its list's ([one], which the fixture's schema names), + * plus whatever [blocked] takes away. + */ + private fun relayLists(blocked: List = emptyList()): List = + GroupRelayList.allAmong(emptyList(), chatRoomId).map { list -> + when (list.set) { + GroupRelaySet.General -> GroupRelayList( + set = list.set, + signedEvent = GroupSignedWorkFixtures.relaySignedEvent(list.set), + relays = listOf(GroupRelay(two)), + ) + GroupRelaySet.Blocked -> GroupRelayList( + set = list.set, + signedEvent = GroupSignedWorkFixtures.relaySignedEvent(list.set), + relays = blocked.map { GroupRelay(it) }, + ) + else -> list + } + } + + private fun viewModel( + transport: EventPublishTransport, + entries: List = listOf(newest, oldest), + relayLists: List = relayLists(), + ) = GroupCuratedEntriesViewModel( + chatRoomId = chatRoomId, + initialGroupCuratedEntriesUIState = GroupCuratedEntriesUIState.Loaded( + localChatRoom = GroupSignedWorkFixtures.localChatRoom(), + groupCuratedEntries = entries, + relayLists = relayLists, + ), + chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, + publishTransport = transport, + ) + + private fun ok(relay: NormalizedRelayUrl, event: NostrEvent) = NostrPublishResult( + result = NostrIncomingMessage.OkMessage(eventId = event.id, success = true), + relayUrl = relay.url, + ) + + private fun rejected(relay: NormalizedRelayUrl, event: NostrEvent, reason: String) = NostrPublishResult( + result = NostrIncomingMessage.OkMessage(eventId = event.id, success = false, message = reason), + error = NostrPublishException(message = reason), + relayUrl = relay.url, + ) + + private fun GroupCuratedEntriesViewModel.broadcastAllAndWait() { + val job = broadcastAll() + runBlocking { withTimeout(5_000) { job!!.join() } } + } + + // -- where each entry goes ---------------------------------------------------- + + @Test + fun `each entry goes where its own broadcast would, one after another, in the order shown`() { + val transport = FakeTransport { event -> listOf(ok(two, event), ok(one, event)) } + val viewModel = viewModel(transport) + + viewModel.broadcastAllAndWait() + + // The newest first, as the screen lists them, and nothing twice. + assertEquals( + listOf(newest.signedEvent.id, oldest.signedEvent.id), + transport.sends.map { it.first.id }, + ) + + // The group's General relay and the list's own, asked as write relays + // -- the pool would otherwise read from them too -- and what went was + // the event as the group signed it. + transport.sends.forEach { (event, relays) -> + assertEquals( + setOf(two, one).map { RelayDTO(url = it.url, read = false, write = true) }.toSet(), + relays, + ) + assertEquals("f".repeat(128), event.sig) + assertEquals(chatRoomId, event.pubKey) + } + } + + @Test + fun `a relay the group has blocked is left out, and an entry with nowhere to go is marked so`() { + val transport = FakeTransport { event -> listOf(ok(two, event)) } + + // Everything the seed would name is blocked, so nothing is asked. + val nowhere = viewModel(transport, relayLists = relayLists(blocked = listOf(one, two))) + nowhere.broadcastAllAndWait() + + assertTrue(transport.sends.isEmpty(), "an entry with nowhere to go was sent somewhere") + assertEquals(EntryBroadcast.NoRelays, nowhere.entryBroadcasts[newest.signedEvent.id]) + assertEquals(EntryBroadcast.NoRelays, nowhere.entryBroadcasts[oldest.signedEvent.id]) + assertEquals( + BroadcastAllProgress.Done(acceptedEverywhere = 0, total = 2), + nowhere.broadcastAllProgress, + ) + + // Only the list's relay blocked: the group's own is still asked. + val partly = viewModel(transport, relayLists = relayLists(blocked = listOf(one))) + partly.broadcastAllAndWait() + + assertEquals(2, transport.sends.size) + transport.sends.forEach { (_, relays) -> + assertEquals(setOf(two.url), relays.map { it.url }.toSet()) + } + } + + // -- what the answers become --------------------------------------------------- + + @Test + fun `each entry's count sits under it, a refusal is named with its reason, and the sum counts only the entries accepted everywhere`() { + val transport = FakeTransport { event -> + if (event.id == newest.signedEvent.id) { + listOf(ok(two, event), ok(one, event)) + } else { + listOf(ok(two, event), rejected(one, event, "blocked: not on the allow list")) + } + } + val viewModel = viewModel(transport) + + viewModel.broadcastAllAndWait() + + val first = assertIs(viewModel.entryBroadcasts[newest.signedEvent.id]) + assertEquals(2, first.accepted) + assertEquals(2, first.asked) + assertTrue(first.isAcceptedEverywhere) + assertEquals(emptyList(), first.refusals) + + val second = assertIs(viewModel.entryBroadcasts[oldest.signedEvent.id]) + assertEquals(1, second.accepted) + assertEquals(2, second.asked) + assertFalse(second.isAcceptedEverywhere) + assertEquals( + listOf(one to RelayOutcome.Rejected("blocked: not on the allow list")), + second.refusals, + ) + + assertEquals( + BroadcastAllProgress.Done(acceptedEverywhere = 1, total = 2), + viewModel.broadcastAllProgress, + ) + assertFalse(viewModel.isActionPending.value) + } + + @Test + fun `a relay that never answers counts against the entry, which is not the same as refused`() { + // The pool answers for one relay and then the flow ends, which is what + // a send that ran out of time looks like from here. + val transport = FakeTransport { event -> listOf(ok(two, event)) } + val viewModel = viewModel(transport, entries = listOf(newest)) + + viewModel.broadcastAllAndWait() + + val sent = assertIs(viewModel.entryBroadcasts[newest.signedEvent.id]) + assertEquals(listOf(one to RelayOutcome.NoAnswer), sent.refusals) + assertEquals( + BroadcastAllProgress.Done(acceptedEverywhere = 0, total = 1), + viewModel.broadcastAllProgress, + ) + } + + // -- when nothing is sent ---------------------------------------------------------- + + @Test + fun `the next entry waits for the last to settle, and a second press while one is out is refused`() { + val gate = CompletableDeferred() + val transport = FakeTransport(gate) { event -> listOf(ok(two, event), ok(one, event)) } + val viewModel = viewModel(transport) + + // The first press is held at the transport, so the second meets the + // guard however fast the dispatcher is. + val first = viewModel.broadcastAll() + val second = viewModel.broadcastAll() + assertNull(second) + assertTrue(viewModel.isActionPending.value) + + // One entry out and held; the other has not been asked for, and the + // held one is marked as out while the rest are marked as nothing. + runBlocking { withTimeout(5_000) { transport.arrived.await() } } + assertEquals(listOf(newest.signedEvent.id), transport.sends.map { it.first.id }) + assertEquals(EntryBroadcast.Sending, viewModel.entryBroadcasts[newest.signedEvent.id]) + assertNull(viewModel.entryBroadcasts[oldest.signedEvent.id]) + assertEquals(BroadcastAllProgress.Sending(entry = 1, total = 2), viewModel.broadcastAllProgress) + + gate.complete(Unit) + runBlocking { withTimeout(5_000) { first!!.join() } } + + assertEquals(2, transport.sends.size) + assertFalse(viewModel.isActionPending.value) + } + + @Test + fun `nothing is sent from a screen with no entries, or one that has not loaded`() { + val transport = FakeTransport { event -> listOf(ok(two, event)) } + + assertNull(viewModel(transport, entries = emptyList()).broadcastAll()) + + val loading = GroupCuratedEntriesViewModel( + chatRoomId = chatRoomId, + initialGroupCuratedEntriesUIState = GroupCuratedEntriesUIState.Loading, + chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, + publishTransport = transport, + ) + assertNull(loading.broadcastAll()) + + assertTrue(transport.sends.isEmpty()) + } +}