mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-24 23:45:18 +00:00
jackandClaude Fable 5
6bda919dd4
NostrRelayManager no longer strands work when Tor is slow to bootstrap: failed readiness waits retry (bounded by nostrTorReadyMaxWaitAttempts) instead of dropping queued relay connections, parked EOSE callbacks fire after exhaustion so callers never hang, and sends made before Tor is ready are queued locally (capped) instead of being dropped on a failed wait - still strictly fail-closed. MessageRouter now prefers a connected transport over a merely window-reachable one, and sends made on a weak reachability signal are retained in the outbox until a delivery/read ack confirms receipt (receivers dedup by message ID), with resends bounded by attempt count. GCS sync filters from the wire are bounds-checked (p in 1...32, m > 1) at both the packet decode and filter decode layers; oversized Golomb parameters previously decoded to garbage via silent shift overflow. BLELinkStateStore is now explicitly pinned to bleQueue: debug builds trap any access from another queue, enforcing the ownership discipline the surrounding code already relied on by convention. CI gains an iOS simulator build job (arm64 only; the vendored Arti xcframework has no x86_64 simulator slice) so iOS-conditional code paths are compile-checked - SPM tests only cover the macOS slice. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
138 lines
4.8 KiB
Swift
138 lines
4.8 KiB
Swift
//
|
|
// MessageRouterTests.swift
|
|
// bitchatTests
|
|
//
|
|
// Tests for MessageRouter transport selection and outbox behavior.
|
|
//
|
|
|
|
import Testing
|
|
import Foundation
|
|
import BitFoundation
|
|
@testable import bitchat
|
|
|
|
struct MessageRouterTests {
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_usesReachableTransport() async {
|
|
let peerID = PeerID(str: "0000000000000001")
|
|
let transportA = MockTransport()
|
|
let transportB = MockTransport()
|
|
transportB.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transportA, transportB])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m1")
|
|
|
|
#expect(transportA.sentPrivateMessages.isEmpty)
|
|
#expect(transportB.sentPrivateMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_queuesThenFlushesWhenReachable() async {
|
|
let peerID = PeerID(str: "0000000000000002")
|
|
let transport = MockTransport()
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Queued", to: peerID, recipientNickname: "Peer", messageID: "m2")
|
|
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
|
|
transport.reachablePeers.insert(peerID)
|
|
router.flushOutbox(for: peerID)
|
|
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_prefersConnectedTransportOverEarlierReachableOne() async {
|
|
let peerID = PeerID(str: "0000000000000005")
|
|
let reachableOnly = MockTransport()
|
|
reachableOnly.reachablePeers.insert(peerID)
|
|
let connected = MockTransport()
|
|
connected.connectedPeers.insert(peerID)
|
|
connected.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [reachableOnly, connected])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m5")
|
|
|
|
#expect(reachableOnly.sentPrivateMessages.isEmpty)
|
|
#expect(connected.sentPrivateMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_reachableOnlySendRetainsUntilDeliveryAck() async {
|
|
let peerID = PeerID(str: "0000000000000006")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m6")
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
// No ack yet: a flush retries over the weak signal.
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
// Ack clears the retained copy; later flushes stop resending.
|
|
router.markDelivered("m6")
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_connectedSendIsNotRetained() async {
|
|
let peerID = PeerID(str: "0000000000000007")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m7")
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func flushOutbox_dropsUnackedMessageAfterAttemptCap() async {
|
|
let peerID = PeerID(str: "0000000000000008")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m8")
|
|
|
|
for _ in 0..<10 {
|
|
router.flushOutbox(for: peerID)
|
|
}
|
|
|
|
// Initial send plus capped resends; never unbounded.
|
|
#expect(transport.sentPrivateMessages.count == 8)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendReadReceipt_usesReachableTransport() async {
|
|
let peerID = PeerID(str: "0000000000000003")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
let receipt = ReadReceipt(originalMessageID: "m3", readerID: transport.myPeerID, readerNickname: "Me")
|
|
router.sendReadReceipt(receipt, to: peerID)
|
|
|
|
#expect(transport.sentReadReceipts.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendFavoriteNotification_usesConnectedOrReachable() async {
|
|
let peerID = PeerID(str: "0000000000000004")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendFavoriteNotification(to: peerID, isFavorite: true)
|
|
|
|
#expect(transport.sentFavoriteNotifications.count == 1)
|
|
}
|
|
}
|