mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-26 09:05:20 +00:00
1243 lines
52 KiB
Swift
1243 lines
52 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 peerBoundDeliveryAckCannotClearAnotherPeersRetainedMessage() async {
|
|
let intendedPeer = PeerID(str: "0000000000000023")
|
|
let otherPeer = PeerID(str: "0000000000000024")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers = [intendedPeer, otherPeer]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate(
|
|
"Secret",
|
|
to: intendedPeer,
|
|
recipientNickname: "Intended",
|
|
messageID: "peer-bound-ack"
|
|
)
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
// Even a receipt arriving over another authenticated conversation
|
|
// must not terminalize the intended peer's retained retry.
|
|
router.markDelivered("peer-bound-ack", from: [otherPeer])
|
|
router.flushOutbox(for: intendedPeer)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
router.markDelivered("peer-bound-ack", from: [intendedPeer])
|
|
router.flushOutbox(for: intendedPeer)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_connectedSecureSendRetainsUntilDeliveryAck() async {
|
|
let peerID = PeerID(str: "0000000000000007")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.reachablePeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m7")
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
// A newly authenticated/replacement session retries the retained
|
|
// message instead of losing the first ciphertext to a stale session.
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [peerID])
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
router.markDelivered("m7")
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [peerID])
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_matchesStableOutboxAliasWithoutDoubleSending() async {
|
|
let shortPeerID = PeerID(str: "0000000000000019")
|
|
let stablePeerID = PeerID(hexData: Data(repeating: 0x19, count: 32))
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(stablePeerID)
|
|
transport.securePeers = [stablePeerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: stablePeerID, recipientNickname: "Peer", messageID: "alias-retry")
|
|
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [shortPeerID, stablePeerID, stablePeerID])
|
|
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["alias-retry", "alias-retry"])
|
|
#expect(transport.sentPrivateMessages.allSatisfy { $0.peerID == stablePeerID })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_preservesFIFOAcrossSplitAliases() async {
|
|
let shortPeerID = PeerID(str: "0000000000000022")
|
|
let stablePeerID = PeerID(hexData: Data(repeating: 0x22, count: 32))
|
|
let transport = MockTransport()
|
|
transport.connectedPeers = [shortPeerID, stablePeerID]
|
|
transport.securePeers = [shortPeerID, stablePeerID]
|
|
let clock = MutableTestClock()
|
|
let router = MessageRouter(transports: [transport], now: { clock.now })
|
|
|
|
// The older message lives under the stable key, even though the auth
|
|
// callback supplies the ephemeral alias first.
|
|
router.sendPrivate("Older", to: stablePeerID, recipientNickname: "Peer", messageID: "fifo-old")
|
|
clock.now = clock.now.addingTimeInterval(1)
|
|
router.sendPrivate("Newer", to: shortPeerID, recipientNickname: "Peer", messageID: "fifo-new")
|
|
transport.resetRecordings()
|
|
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [shortPeerID, stablePeerID])
|
|
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["fifo-old", "fifo-new"])
|
|
#expect(transport.sentPrivateMessages.map(\.peerID) == [stablePeerID, shortPeerID])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_doesNotDuplicateNormalPendingHandshakeSend() async {
|
|
let peerID = PeerID(str: "0000000000000020")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = []
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "normal-handshake")
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
// BLE owns this pending send and drains it after authentication. Once
|
|
// the session becomes secure, the router's targeted auth retry must
|
|
// stay silent instead of producing a second copy.
|
|
transport.securePeers = [peerID]
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [peerID])
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
router.markDelivered("normal-handshake")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_scopesCollidingMessageIDsByPeer() async {
|
|
let securePeer = PeerID(str: "0000000000000025")
|
|
let pendingPeer = PeerID(str: "0000000000000026")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers = [securePeer, pendingPeer]
|
|
transport.securePeers = [securePeer]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
let promotedID = "collision-promoted"
|
|
let clearedID = "collision-cleared"
|
|
|
|
// Pending B then secure A: an ID-global marker falsely promotes B.
|
|
router.sendPrivate(
|
|
"pending promoted",
|
|
to: pendingPeer,
|
|
recipientNickname: "Pending",
|
|
messageID: promotedID
|
|
)
|
|
router.sendPrivate(
|
|
"secure promoted",
|
|
to: securePeer,
|
|
recipientNickname: "Secure",
|
|
messageID: promotedID
|
|
)
|
|
|
|
// Secure A then pending B: an ID-global removal falsely clears A.
|
|
router.sendPrivate(
|
|
"secure cleared",
|
|
to: securePeer,
|
|
recipientNickname: "Secure",
|
|
messageID: clearedID
|
|
)
|
|
router.sendPrivate(
|
|
"pending cleared",
|
|
to: pendingPeer,
|
|
recipientNickname: "Pending",
|
|
messageID: clearedID
|
|
)
|
|
|
|
transport.resetRecordings()
|
|
transport.securePeers = [securePeer, pendingPeer]
|
|
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [pendingPeer])
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [securePeer])
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
#expect(Set(transport.sentPrivateMessages.map(\.messageID)) == [promotedID, clearedID])
|
|
#expect(transport.sentPrivateMessages.allSatisfy { $0.peerID == securePeer })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_doesNotDuplicateMessageRequeuedByBLEForHandshake() async {
|
|
let peerID = PeerID(str: "0000000000000021")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "session-lost")
|
|
#expect(transport.sentPrivateMessages.count == 1)
|
|
|
|
// The session disappears before a normal outbox flush. That send is
|
|
// now owned by BLE's pending-handshake queue, so it clears the
|
|
// router's secure-auth retry marker.
|
|
transport.securePeers = []
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
transport.securePeers = [peerID]
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [peerID])
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
router.markDelivered("session-lost")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_fastDeliveryAckCannotRaceAheadOfRetention() async {
|
|
let peerID = PeerID(str: "0000000000000017")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
transport.onSendPrivateMessage = { messageID in
|
|
router.markDelivered(messageID)
|
|
}
|
|
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "fast-ack")
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["fast-ack"])
|
|
|
|
transport.onSendPrivateMessage = nil
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["fast-ack"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func flushOutbox_synchronousAckDoesNotResurrectSnapshotEntry() async {
|
|
let peerID = PeerID(str: "0000000000000018")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "flush-fast-ack")
|
|
transport.onSendPrivateMessage = { messageID in
|
|
router.markDelivered(messageID)
|
|
}
|
|
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
|
|
transport.onSendPrivateMessage = nil
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
}
|
|
|
|
@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)
|
|
}
|
|
|
|
// MARK: - Drop visibility (onMessageDropped)
|
|
|
|
@Test @MainActor
|
|
func flushOutbox_attemptCapDropInvokesOnMessageDropped() async {
|
|
let peerID = PeerID(str: "0000000000000009")
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
var dropped: [(messageID: String, peerID: PeerID)] = []
|
|
router.onMessageDropped = { dropped.append(($0, $1)) }
|
|
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m9")
|
|
for _ in 0..<10 {
|
|
router.flushOutbox(for: peerID)
|
|
}
|
|
|
|
#expect(dropped.count == 1)
|
|
#expect(dropped.first?.messageID == "m9")
|
|
#expect(dropped.first?.peerID == peerID)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func flushOutbox_ttlExpiryInvokesOnMessageDroppedAndDoesNotResend() async {
|
|
let peerID = PeerID(str: "000000000000000a")
|
|
let transport = MockTransport()
|
|
let clock = MutableTestClock()
|
|
|
|
let router = MessageRouter(transports: [transport], now: { clock.now })
|
|
var dropped: [String] = []
|
|
router.onMessageDropped = { messageID, _ in dropped.append(messageID) }
|
|
|
|
// No reachable transport: the message is queued, never sent.
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "m10")
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
|
|
// Past the 24h TTL the flush must drop it (visibly), not send it.
|
|
clock.now = clock.now.addingTimeInterval(24 * 60 * 60 + 1)
|
|
transport.reachablePeers.insert(peerID)
|
|
router.flushOutbox(for: peerID)
|
|
|
|
#expect(dropped == ["m10"])
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
|
|
// The drop is final: nothing is retained for later flushes.
|
|
router.flushOutbox(for: peerID)
|
|
#expect(dropped == ["m10"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func cleanupExpiredMessages_invokesOnMessageDroppedForExpiredOnly() async {
|
|
let peerID = PeerID(str: "000000000000000b")
|
|
let transport = MockTransport()
|
|
let clock = MutableTestClock()
|
|
|
|
let router = MessageRouter(transports: [transport], now: { clock.now })
|
|
var dropped: [String] = []
|
|
router.onMessageDropped = { messageID, _ in dropped.append(messageID) }
|
|
|
|
router.sendPrivate("Old", to: peerID, recipientNickname: "Peer", messageID: "m11-old")
|
|
clock.now = clock.now.addingTimeInterval(24 * 60 * 60 - 60)
|
|
router.sendPrivate("Fresh", to: peerID, recipientNickname: "Peer", messageID: "m11-fresh")
|
|
clock.now = clock.now.addingTimeInterval(120)
|
|
|
|
router.cleanupExpiredMessages()
|
|
|
|
#expect(dropped == ["m11-old"])
|
|
|
|
// The fresh message survived and still flushes once reachable.
|
|
transport.reachablePeers.insert(peerID)
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["m11-fresh"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func enqueue_perPeerOverflowEvictionInvokesOnMessageDropped() async {
|
|
let peerID = PeerID(str: "000000000000000c")
|
|
let transport = MockTransport()
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
var dropped: [String] = []
|
|
router.onMessageDropped = { messageID, _ in dropped.append(messageID) }
|
|
|
|
// No reachable transport: everything queues. The cap is 100 per peer,
|
|
// so the 101st enqueue evicts the oldest.
|
|
for i in 0...100 {
|
|
router.sendPrivate("Hello \(i)", to: peerID, recipientNickname: "Peer", messageID: "q\(i)")
|
|
}
|
|
|
|
#expect(dropped == ["q0"])
|
|
}
|
|
|
|
@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)
|
|
}
|
|
|
|
// MARK: - Courier deposits
|
|
|
|
private static func snapshot(_ peerID: PeerID, key: Data, verified: Bool) -> TransportPeerSnapshot {
|
|
TransportPeerSnapshot(
|
|
peerID: peerID,
|
|
nickname: "peer",
|
|
isConnected: true,
|
|
noisePublicKey: key,
|
|
lastSeen: Date(),
|
|
isVerified: verified
|
|
)
|
|
}
|
|
|
|
/// Directory that resolves one offline recipient and treats a fixed key
|
|
/// set as mutual favorites.
|
|
private static func directory(recipient: PeerID, recipientKey: Data, favoriteKeys: Set<Data> = []) -> CourierDirectory {
|
|
CourierDirectory(
|
|
noiseKey: { peerID in peerID == recipient ? recipientKey : nil },
|
|
isTrustedCourier: { favoriteKeys.contains($0) }
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_depositsWithVerifiedStrangerWhenNoFavoriteAround() async {
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let recipientKey = Data(repeating: 0xBB, count: 32)
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
let courierKey = Data(repeating: 0xCC, count: 32)
|
|
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(courier)
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: courierKey, verified: true)])
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey)
|
|
)
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "cv1")
|
|
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
#expect(transport.sentCourierMessages.first?.couriers == [courier])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_neverDepositsWithUnverifiedStranger() async {
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(courier)
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: Data(repeating: 0xCC, count: 32), verified: false)])
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: Data(repeating: 0xBB, count: 32))
|
|
)
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "cv2")
|
|
|
|
#expect(transport.sentCourierMessages.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivate_prefersFavoriteCouriersOverVerifiedOnes() async {
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let recipientKey = Data(repeating: 0xBB, count: 32)
|
|
let favorite = PeerID(str: "00000000000000f0")
|
|
let favoriteKey = Data(repeating: 0xF0, count: 32)
|
|
var snapshots = [Self.snapshot(favorite, key: favoriteKey, verified: false)]
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(favorite)
|
|
// Three verified strangers compete for the three courier slots.
|
|
for byte: UInt8 in [0xC1, 0xC2, 0xC3] {
|
|
let peer = PeerID(str: String(format: "00000000000000%02x", byte))
|
|
transport.connectedPeers.insert(peer)
|
|
snapshots.append(Self.snapshot(peer, key: Data(repeating: byte, count: 32), verified: true))
|
|
}
|
|
transport.updatePeerSnapshots(snapshots)
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey, favoriteKeys: [favoriteKey])
|
|
)
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "cv3")
|
|
|
|
let couriers = transport.sentCourierMessages.first?.couriers ?? []
|
|
#expect(couriers.count == 3)
|
|
#expect(couriers.contains(favorite))
|
|
}
|
|
|
|
/// Residual gap after the rotation-heal containment: a replayed "direct"
|
|
/// announce (TTL is unsigned) can bind an absent victim's peer ID to the
|
|
/// replayer's link, leaving the victim "connected" on a link whose Noise
|
|
/// handshake can never complete. The connected fast-path must not trust
|
|
/// that outright: the send still goes out (a genuine link finishes the
|
|
/// handshake), but a copy is retained and a sealed copy goes to couriers
|
|
/// so nothing is silently lost.
|
|
@Test @MainActor
|
|
func sendPrivate_connectedWithoutSecureSessionRetainsAndDepositsWithCourier() async {
|
|
let victim = PeerID(str: "00000000000000aa")
|
|
let victimKey = Data(repeating: 0xBB, count: 32)
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
let courierKey = Data(repeating: 0xCC, count: 32)
|
|
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(victim)
|
|
transport.connectedPeers.insert(courier)
|
|
transport.securePeers = [] // no established Noise session with anyone
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: courierKey, verified: true)])
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: victim, recipientKey: victimKey)
|
|
)
|
|
router.sendPrivate("Hello", to: victim, recipientNickname: "Peer", messageID: "cs1")
|
|
|
|
// The send is still attempted (it kicks the handshake on a genuine
|
|
// link) but not trusted outright: a courier gets a sealed copy now …
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["cs1"])
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
#expect(transport.sentCourierMessages.first?.messageID == "cs1")
|
|
#expect(transport.sentCourierMessages.first?.recipientNoiseKey == victimKey)
|
|
#expect(transport.sentCourierMessages.first?.couriers == [courier])
|
|
|
|
// … and the retained copy keeps flushing until a delivery ack — a
|
|
// flush over the insecure link must resend without dropping it.
|
|
router.flushOutbox(for: victim)
|
|
router.flushOutbox(for: victim)
|
|
#expect(transport.sentPrivateMessages.count == 3)
|
|
router.markDelivered("cs1")
|
|
router.flushOutbox(for: victim)
|
|
#expect(transport.sentPrivateMessages.count == 3)
|
|
}
|
|
|
|
/// Flushes over a connected-but-insecure link never count toward the
|
|
/// attempt-cap drop: the message was actually transmitted over a live
|
|
/// link, so a peer whose Noise handshake stalls across reconnect flapping
|
|
/// must not burn through the cap and lose the store-and-forward copy the
|
|
/// secure-session gate exists to preserve. Retention stays bounded by
|
|
/// the 24h outbox TTL and the per-peer FIFO cap; an ack clears it.
|
|
@Test @MainActor
|
|
func flushOutbox_connectedInsecureFlushesNeverDropTheRetainedCopy() async {
|
|
let peerID = PeerID(str: "00000000000000ac")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [] // handshake never completes
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
var dropped: [String] = []
|
|
router.onMessageDropped = { messageID, _ in dropped.append(messageID) }
|
|
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "ci1")
|
|
|
|
// Well past maxSendAttempts (8): every flush resends, none drops.
|
|
for _ in 0..<10 {
|
|
router.flushOutbox(for: peerID)
|
|
}
|
|
#expect(dropped.isEmpty)
|
|
#expect(transport.sentPrivateMessages.count == 11)
|
|
|
|
// The copy is still retained and an ack still clears it.
|
|
router.markDelivered("ci1")
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 11)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func authenticationRetry_capsActualSecureTransmissions() async {
|
|
let peerID = PeerID(str: "00000000000000ad")
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
|
|
let router = MessageRouter(transports: [transport])
|
|
var dropped: [String] = []
|
|
router.onMessageDropped = { messageID, _ in dropped.append(messageID) }
|
|
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "secure-retry")
|
|
for _ in 0..<10 {
|
|
router.retrySecurePrivateMessagesAfterAuthentication(for: [peerID])
|
|
}
|
|
|
|
#expect(dropped == ["secure-retry"])
|
|
#expect(transport.sentPrivateMessages.count == 8)
|
|
}
|
|
|
|
/// With an established secure session the connected fast-path sends
|
|
/// immediately and never leaks to couriers, but retains a local encrypted
|
|
/// outbox copy until the peer confirms receipt.
|
|
@Test @MainActor
|
|
func sendPrivate_connectedWithSecureSessionRetainsLocallyWithoutCourier() async {
|
|
let peerID = PeerID(str: "00000000000000ab")
|
|
let peerKey = Data(repeating: 0xAB, count: 32)
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.connectedPeers.insert(courier)
|
|
transport.securePeers = [peerID]
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: Data(repeating: 0xCC, count: 32), verified: true)])
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: peerID, recipientKey: peerKey)
|
|
)
|
|
router.sendPrivate("Hello", to: peerID, recipientNickname: "Peer", messageID: "cs2")
|
|
|
|
#expect(transport.sentPrivateMessages.map(\.messageID) == ["cs2"])
|
|
#expect(transport.sentCourierMessages.isEmpty)
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
#expect(transport.sentCourierMessages.isEmpty)
|
|
router.markDelivered("cs2")
|
|
router.flushOutbox(for: peerID)
|
|
#expect(transport.sentPrivateMessages.count == 2)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func courierBecameAvailable_retriesDepositOnceWithoutDoubleBurn() async {
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let recipientKey = Data(repeating: 0xBB, count: 32)
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
let courierKey = Data(repeating: 0xCC, count: 32)
|
|
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey)
|
|
)
|
|
// Nobody around at send time: the message just queues.
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "cr1")
|
|
#expect(transport.sentCourierMessages.isEmpty)
|
|
|
|
// A verified courier appears later: the deposit retries.
|
|
transport.connectedPeers.insert(courier)
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: courierKey, verified: true)])
|
|
router.courierBecameAvailable(courier)
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
#expect(transport.sentCourierMessages.first?.couriers == [courier])
|
|
|
|
// The same courier reconnecting does not receive the same mail twice.
|
|
router.courierBecameAvailable(courier)
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func enqueueReplacementCarriesOverDepositedCourierKeys() async {
|
|
// Re-sending a queued message ID replaces the outbox entry; the
|
|
// replacement must inherit which couriers already carry the message,
|
|
// or the deposit retry re-burns the same courier slots (duplicate
|
|
// sealed copies to the same peer).
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let recipientKey = Data(repeating: 0xBB, count: 32)
|
|
let courier = PeerID(str: "00000000000000cc")
|
|
let courierKey = Data(repeating: 0xCC, count: 32)
|
|
|
|
let transport = MockTransport()
|
|
transport.connectedPeers.insert(courier)
|
|
transport.updatePeerSnapshots([Self.snapshot(courier, key: courierKey, verified: true)])
|
|
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey)
|
|
)
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "ck1")
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
|
|
// Same message ID re-sent (e.g. a resend while still queued): the
|
|
// courier already carrying it must not receive a second copy.
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "ck1")
|
|
#expect(transport.sentCourierMessages.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func courierBecameAvailable_ignoresTheRecipientThemselves() async {
|
|
let recipient = PeerID(str: "00000000000000aa")
|
|
let recipientKey = Data(repeating: 0xBB, count: 32)
|
|
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey)
|
|
)
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "cr2")
|
|
|
|
// The recipient connecting is a flush, not a courier opportunity.
|
|
transport.connectedPeers.insert(recipient)
|
|
transport.updatePeerSnapshots([Self.snapshot(recipient, key: recipientKey, verified: true)])
|
|
router.courierBecameAvailable(recipient)
|
|
#expect(transport.sentCourierMessages.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func bridgeDepositCarriesOnlyAfterConfirmedSendAndRetriesFailure() async {
|
|
let recipient = PeerID(str: "00000000000000ba")
|
|
let recipientKey = Data(repeating: 0xBA, count: 32)
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
courierDirectory: Self.directory(recipient: recipient, recipientKey: recipientKey)
|
|
)
|
|
var completions: [@MainActor (Bool) -> Void] = []
|
|
router.bridgeCourierDeposit = { _, _, _, completion in
|
|
completions.append(completion)
|
|
}
|
|
var carried: [String] = []
|
|
router.onMessageCarried = { messageID, _ in carried.append(messageID) }
|
|
|
|
router.sendPrivate("Hello", to: recipient, recipientNickname: "Peer", messageID: "bridge-ack")
|
|
#expect(completions.count == 1)
|
|
#expect(carried.isEmpty)
|
|
|
|
// Sweeps while the WebSocket write is pending must not duplicate it.
|
|
router.retryBridgeCourierDeposits()
|
|
#expect(completions.count == 1)
|
|
|
|
completions.removeFirst()(false)
|
|
#expect(carried.isEmpty)
|
|
|
|
// A failed socket write releases the in-flight slot for a real retry.
|
|
router.retryBridgeCourierDeposits()
|
|
#expect(completions.count == 1)
|
|
completions.removeFirst()(true)
|
|
#expect(carried == ["bridge-ack"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func bridgeDepositsScopeCollidingMessageIDsByRecipient() async {
|
|
let firstRecipient = PeerID(str: "00000000000000b1")
|
|
let secondRecipient = PeerID(str: "00000000000000b2")
|
|
let firstKey = Data(repeating: 0xB1, count: 32)
|
|
let secondKey = Data(repeating: 0xB2, count: 32)
|
|
let recipientKeys = [
|
|
firstRecipient: firstKey,
|
|
secondRecipient: secondKey
|
|
]
|
|
let router = MessageRouter(
|
|
transports: [MockTransport()],
|
|
courierDirectory: CourierDirectory(
|
|
noiseKey: { recipientKeys[$0] },
|
|
isTrustedCourier: { _ in false }
|
|
)
|
|
)
|
|
var requestedKeys: [Data] = []
|
|
var completions: [@MainActor (Bool) -> Void] = []
|
|
router.bridgeCourierDeposit = { _, _, recipientKey, completion in
|
|
requestedKeys.append(recipientKey)
|
|
completions.append(completion)
|
|
}
|
|
var carriedPeers: [PeerID] = []
|
|
router.onMessageCarried = { _, peerID in carriedPeers.append(peerID) }
|
|
|
|
router.sendPrivate(
|
|
"First",
|
|
to: firstRecipient,
|
|
recipientNickname: "First",
|
|
messageID: "bridge-collision"
|
|
)
|
|
router.sendPrivate(
|
|
"Second",
|
|
to: secondRecipient,
|
|
recipientNickname: "Second",
|
|
messageID: "bridge-collision"
|
|
)
|
|
|
|
#expect(completions.count == 2)
|
|
#expect(Set(requestedKeys) == [firstKey, secondKey])
|
|
|
|
completions.forEach { $0(true) }
|
|
#expect(Set(carriedPeers) == [firstRecipient, secondRecipient])
|
|
}
|
|
|
|
// MARK: - Outbox persistence
|
|
|
|
@Test @MainActor
|
|
func queuedMessagesSurviveRouterRestart() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-outbox-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000dd")
|
|
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
outboxStore: MessageOutboxStore(keychain: keychain, fileURL: fileURL)
|
|
)
|
|
router.sendPrivate("Survive", to: peerID, recipientNickname: "Peer", messageID: "p1")
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
|
|
// "App restart": a fresh router over the same store, peer now around.
|
|
let transport2 = MockTransport()
|
|
transport2.reachablePeers.insert(peerID)
|
|
let router2 = MessageRouter(
|
|
transports: [transport2],
|
|
outboxStore: MessageOutboxStore(keychain: keychain, fileURL: fileURL)
|
|
)
|
|
router2.flushOutbox(for: peerID)
|
|
#expect(transport2.sentPrivateMessages.map(\.messageID) == ["p1"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func deliveredMessagesDoNotResurrectAfterRestart() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-outbox-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000de")
|
|
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
outboxStore: MessageOutboxStore(keychain: keychain, fileURL: fileURL)
|
|
)
|
|
router.sendPrivate("Once", to: peerID, recipientNickname: "Peer", messageID: "p2")
|
|
router.markDelivered("p2")
|
|
|
|
let transport2 = MockTransport()
|
|
transport2.reachablePeers.insert(peerID)
|
|
let router2 = MessageRouter(
|
|
transports: [transport2],
|
|
outboxStore: MessageOutboxStore(keychain: keychain, fileURL: fileURL)
|
|
)
|
|
router2.flushOutbox(for: peerID)
|
|
#expect(transport2.sentPrivateMessages.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func scopedDeliveryAckClearsOnlySelectedPeerWhenMessageIDsCollide() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-outbox-scoped-ack-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let acknowledgedPeer = PeerID(str: "00000000000000d1")
|
|
let otherPeer = PeerID(str: "00000000000000d2")
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(
|
|
transports: [transport],
|
|
outboxStore: MessageOutboxStore(keychain: keychain, fileURL: fileURL)
|
|
)
|
|
router.sendPrivate("For acknowledged peer", to: acknowledgedPeer, recipientNickname: "One", messageID: "shared-id")
|
|
router.sendPrivate("For other peer", to: otherPeer, recipientNickname: "Two", messageID: "shared-id")
|
|
|
|
#expect(router.markDelivered("shared-id", for: [acknowledgedPeer]))
|
|
transport.reachablePeers.formUnion([acknowledgedPeer, otherPeer])
|
|
router.flushOutbox(for: acknowledgedPeer)
|
|
router.flushOutbox(for: otherPeer)
|
|
|
|
#expect(transport.sentPrivateMessages.map(\.peerID) == [otherPeer])
|
|
let persisted = MessageOutboxStore(keychain: keychain, fileURL: fileURL).load()
|
|
#expect(persisted[acknowledgedPeer] == nil)
|
|
#expect(persisted[otherPeer]?.map(\.messageID) == ["shared-id"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func scopedAckWhileColdLoadIsLockedPreventsOnlyTargetPeerResurrection() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-locked-scoped-ack-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let acknowledgedPeer = PeerID(str: "00000000000000d3")
|
|
let otherPeer = PeerID(str: "00000000000000d4")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Queued before reboot",
|
|
nickname: "Peer",
|
|
messageID: "shared-locked-id",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([
|
|
acknowledgedPeer: [durable],
|
|
otherPeer: [durable]
|
|
])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.formUnion([acknowledgedPeer, otherPeer])
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
|
|
router.markDelivered(
|
|
"shared-locked-id",
|
|
from: [acknowledgedPeer]
|
|
)
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad()
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
#expect(transport.sentPrivateMessages.map(\.peerID) == [otherPeer])
|
|
let persisted = MessageOutboxStore(keychain: keychain, fileURL: fileURL).load()
|
|
#expect(persisted[acknowledgedPeer] == nil)
|
|
#expect(persisted[otherPeer]?.map(\.messageID) == ["shared-locked-id"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func protectedDataRecoveryMergesDurableAndLockedWakeMessagesIntoRouter() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-protected-data-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000df")
|
|
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Before reboot",
|
|
nickname: "Peer",
|
|
messageID: "durable",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
router.sendPrivate("During wake", to: peerID, recipientNickname: "Peer", messageID: "wake")
|
|
|
|
transport.reachablePeers.insert(peerID)
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad()
|
|
// Recovery is delivered to the main actor without blocking the
|
|
// protected-data notification callback.
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
#expect(Set(transport.sentPrivateMessages.map(\.messageID)) == ["durable", "wake"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func ackWhileColdLoadIsLockedDoesNotResurrectUnseenDurableMessage() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-locked-ack-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000e0")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Already delivered",
|
|
nickname: "Peer",
|
|
messageID: "acked-while-locked",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
|
|
// The router's locked cold-load view is empty, but the ack still has
|
|
// to suppress the durable message hidden on disk.
|
|
router.markDelivered("acked-while-locked")
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad()
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
#expect(MessageOutboxStore(keychain: keychain, fileURL: fileURL).load().isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func ackAfterRecoveryCaptureBeforeMainActorMergeCannotResurrectMessage() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-recovery-gap-ack-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000e1")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Captured then acked",
|
|
nickname: "Peer",
|
|
messageID: "recovery-gap-ack",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
transport.reachablePeers.insert(peerID)
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad() // captures recovery and queues MainActor merge
|
|
router.markDelivered("recovery-gap-ack") // runs before that queued Task
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
#expect(MessageOutboxStore(keychain: keychain, fileURL: fileURL).load().isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func enqueueAfterRecoveryCapturePreservesUnseenDurableAndNewMessages() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-recovery-gap-enqueue-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000e2")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Before unlock",
|
|
nickname: "Peer",
|
|
messageID: "recovery-gap-durable",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad() // queues merge of the durable message
|
|
router.sendPrivate("During gap", to: peerID, recipientNickname: "Peer", messageID: "recovery-gap-new")
|
|
transport.reachablePeers.insert(peerID)
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
#expect(Set(transport.sentPrivateMessages.map(\.messageID)) == ["recovery-gap-durable", "recovery-gap-new"])
|
|
let relaunched = MessageOutboxStore(keychain: keychain, fileURL: fileURL).load()
|
|
#expect(Set(relaunched[peerID]?.map(\.messageID) ?? []) == ["recovery-gap-durable", "recovery-gap-new"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func removingKnownWakeMessageInRecoveryGapPreservesOnlyUnseenDurableState() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-recovery-gap-known-removal-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000e3")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Unseen durable",
|
|
nickname: "Peer",
|
|
messageID: "recovery-gap-unseen",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
router.sendPrivate("Known wake", to: peerID, recipientNickname: "Peer", messageID: "recovery-gap-known")
|
|
|
|
protectedDataUnavailable = false
|
|
restoredStore.retryDeferredLoad() // captures unseen durable + known wake
|
|
|
|
// A secure direct retry followed by its delivery ack removes the wake
|
|
// message before recovery's MainActor merge. It must remain removed,
|
|
// while the unseen durable message still arrives through the pending
|
|
// recovery claim.
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
router.flushOutbox(for: peerID)
|
|
router.markDelivered("recovery-gap-known")
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
let sentIDs = transport.sentPrivateMessages.map(\.messageID)
|
|
#expect(sentIDs.filter { $0 == "recovery-gap-known" }.count == 1)
|
|
#expect(sentIDs.filter { $0 == "recovery-gap-unseen" }.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func failedRecoveryWriteStillPreservesUnseenDurableStateAcrossGapRemoval() async {
|
|
let fileURL = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("router-recovery-write-failure-\(UUID().uuidString).sealed")
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let keychain = MockKeychain()
|
|
let peerID = PeerID(str: "00000000000000e4")
|
|
let durable = MessageOutboxStore.QueuedMessage(
|
|
content: "Unseen before unlock",
|
|
nickname: "Peer",
|
|
messageID: "recovery-write-failure-unseen",
|
|
timestamp: Date()
|
|
)
|
|
MessageOutboxStore(keychain: keychain, fileURL: fileURL).save([peerID: [durable]])
|
|
|
|
var protectedDataUnavailable = true
|
|
var failWrites = false
|
|
var injectedFailureCount = 0
|
|
let restoredStore = MessageOutboxStore(
|
|
keychain: keychain,
|
|
fileURL: fileURL,
|
|
readData: { url in
|
|
if protectedDataUnavailable {
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoPermissionError)
|
|
}
|
|
return try Data(contentsOf: url)
|
|
},
|
|
writeData: { data, url, options in
|
|
if failWrites {
|
|
injectedFailureCount += 1
|
|
throw NSError(domain: NSCocoaErrorDomain, code: NSFileWriteNoPermissionError)
|
|
}
|
|
try data.write(to: url, options: options)
|
|
}
|
|
)
|
|
let transport = MockTransport()
|
|
let router = MessageRouter(transports: [transport], outboxStore: restoredStore)
|
|
router.sendPrivate(
|
|
"Known wake",
|
|
to: peerID,
|
|
recipientNickname: "Peer",
|
|
messageID: "recovery-write-failure-known"
|
|
)
|
|
|
|
// The first post-unlock save reads durable D and knows router state W,
|
|
// but its D+W write fails. A later retry must retain the original
|
|
// unseen-D classification instead of mistaking the cached union for
|
|
// a fully router-known snapshot.
|
|
protectedDataUnavailable = false
|
|
failWrites = true
|
|
router.sendPrivate(
|
|
"Known wake",
|
|
to: peerID,
|
|
recipientNickname: "Peer",
|
|
messageID: "recovery-write-failure-known"
|
|
)
|
|
failWrites = false
|
|
#expect(injectedFailureCount == 1)
|
|
|
|
restoredStore.retryDeferredLoad() // persists D+W and queues recovery
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.securePeers = [peerID]
|
|
router.flushOutbox(for: peerID)
|
|
router.markDelivered("recovery-write-failure-known") // removes W before queued callback
|
|
|
|
// The gap save may remove W, but it must leave unseen D durable until
|
|
// MessageRouter receives the pending recovery callback.
|
|
let gapSnapshot = MessageOutboxStore(keychain: keychain, fileURL: fileURL).load()
|
|
#expect(gapSnapshot[peerID]?.map(\.messageID) == ["recovery-write-failure-unseen"])
|
|
|
|
await Task.yield()
|
|
await Task.yield()
|
|
|
|
let sentIDs = transport.sentPrivateMessages.map(\.messageID)
|
|
#expect(sentIDs.filter { $0 == "recovery-write-failure-known" }.count == 1)
|
|
#expect(sentIDs.filter { $0 == "recovery-write-failure-unseen" }.count == 1)
|
|
}
|
|
}
|
|
|
|
/// Mutable wall clock injected into `MessageRouter` so TTL expiry is testable
|
|
/// without real waiting.
|
|
private final class MutableTestClock {
|
|
var now = Date(timeIntervalSince1970: 1_700_000_000)
|
|
}
|