mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-25 10:45:20 +00:00
Extract BLE packet handlers and migrate coordinators to narrow contexts
BLEService's per-packet-type orchestration moves into owned, tested components (BLEAnnounceHandler, BLEPublicMessageHandler, BLENoisePacketHandler, BLEFileTransferHandler, BLEFragmentHandler), each taking an environment struct of closures so every queue hop stays in BLEService and the handlers are synchronously testable. Behavior is preserved verbatim, including Noise session recovery on decrypt failure and single-block UI event ordering. handleLeave/handleRequestSync stay in place as already-thin delegations. BLEService drops to 3393 lines. Four coordinators (delivery, private conversation, Nostr, public conversation) drop their unowned/weak ChatViewModel back-references for narrow @MainActor context protocols, with ChatViewModel conformances as single shared witnesses for overlapping members. Their true coupling is now an explicit, reviewable surface, and each gains a mock-context test suite covering flows previously testable only through the full view model. Delivery/read acks now also clear the router's retained-send outbox via the delivery context. New LargeTopologyTests exercise production-shaped meshes with the in-memory harness: an 8-peer relay chain with per-hop TTL decay, a 14-peer cyclic mesh with exactly-once delivery, partition/heal, and topology churn. App-layer runtime/model files updated alongside. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
jack
@@ -0,0 +1,442 @@
|
||||
//
|
||||
// ChatNostrCoordinatorContextTests.swift
|
||||
// bitchatTests
|
||||
//
|
||||
// Exercises `ChatNostrCoordinator` against a mock `ChatNostrContext` —
|
||||
// proving the coordinator works without a `ChatViewModel`, following the
|
||||
// `ChatDeliveryCoordinatorContextTests` / `ChatPrivateConversationCoordinatorContextTests`
|
||||
// exemplars.
|
||||
//
|
||||
|
||||
import Testing
|
||||
import Foundation
|
||||
import BitFoundation
|
||||
@testable import bitchat
|
||||
|
||||
// MARK: - Mock Context
|
||||
|
||||
/// Lightweight stand-in for `ChatNostrContext` proving that
|
||||
/// `ChatNostrCoordinator` is testable without a `ChatViewModel`.
|
||||
@MainActor
|
||||
private final class MockChatNostrContext: ChatNostrContext {
|
||||
// Channel & subscription state
|
||||
var activeChannel: ChannelID = .mesh
|
||||
var currentGeohash: String?
|
||||
var geoSubscriptionID: String?
|
||||
var geoDmSubscriptionID: String?
|
||||
var geoSamplingSubs: [String: String] = [:]
|
||||
var lastGeoNotificationAt: [String: Date] = [:]
|
||||
var nostrRelayManager: NostrRelayManager? { nil }
|
||||
|
||||
// Public timeline & pipeline
|
||||
var messages: [BitchatMessage] = []
|
||||
private(set) var pipelineResetCount = 0
|
||||
private(set) var pipelineChannelUpdates: [ChannelID] = []
|
||||
private(set) var refreshedChannels: [ChannelID?] = []
|
||||
private(set) var publicSystemMessages: [String] = []
|
||||
var pendingGeohashSystemMessages: [String] = []
|
||||
private(set) var appendedGeohashMessages: [(message: BitchatMessage, geohash: String)] = []
|
||||
private(set) var synchronizedGeohashes: [String] = []
|
||||
|
||||
func resetPublicMessagePipeline() { pipelineResetCount += 1 }
|
||||
func updatePublicMessagePipelineChannel(_ channel: ChannelID) { pipelineChannelUpdates.append(channel) }
|
||||
func refreshVisibleMessages(from channel: ChannelID?) { refreshedChannels.append(channel) }
|
||||
func addPublicSystemMessage(_ content: String) { publicSystemMessages.append(content) }
|
||||
|
||||
func drainPendingGeohashSystemMessages() -> [String] {
|
||||
defer { pendingGeohashSystemMessages.removeAll() }
|
||||
return pendingGeohashSystemMessages
|
||||
}
|
||||
|
||||
func appendGeohashMessageIfAbsent(_ message: BitchatMessage, toGeohash geohash: String) -> Bool {
|
||||
guard !appendedGeohashMessages.contains(where: { $0.message.id == message.id && $0.geohash == geohash }) else {
|
||||
return false
|
||||
}
|
||||
appendedGeohashMessages.append((message, geohash))
|
||||
return true
|
||||
}
|
||||
|
||||
func synchronizePublicConversationStore(forGeohash geohash: String) { synchronizedGeohashes.append(geohash) }
|
||||
|
||||
// Inbound public messages
|
||||
private(set) var handledPublicMessages: [BitchatMessage] = []
|
||||
private(set) var mentionCheckedMessageIDs: [String] = []
|
||||
private(set) var hapticMessageIDs: [String] = []
|
||||
|
||||
func handlePublicMessage(_ message: BitchatMessage) { handledPublicMessages.append(message) }
|
||||
func checkForMentions(_ message: BitchatMessage) { mentionCheckedMessageIDs.append(message.id) }
|
||||
func sendHapticFeedback(for message: BitchatMessage) { hapticMessageIDs.append(message.id) }
|
||||
func parseMentions(from content: String) -> [String] { [] }
|
||||
|
||||
// Inbound private (geohash DM) payloads
|
||||
var selectedPrivateChatPeer: PeerID?
|
||||
var nostrKeyMapping: [PeerID: String] = [:]
|
||||
private(set) var handledPrivateMessages: [(payload: NoisePayload, senderPubkey: String, convKey: PeerID, timestamp: Date)] = []
|
||||
private(set) var handledDelivered: [(senderPubkey: String, convKey: PeerID)] = []
|
||||
private(set) var handledReadReceipts: [(senderPubkey: String, convKey: PeerID)] = []
|
||||
private(set) var startedPrivateChats: [PeerID] = []
|
||||
|
||||
func handlePrivateMessage(
|
||||
_ payload: NoisePayload,
|
||||
senderPubkey: String,
|
||||
convKey: PeerID,
|
||||
id: NostrIdentity,
|
||||
messageTimestamp: Date
|
||||
) {
|
||||
handledPrivateMessages.append((payload, senderPubkey, convKey, messageTimestamp))
|
||||
}
|
||||
|
||||
func handleDelivered(_ payload: NoisePayload, senderPubkey: String, convKey: PeerID) {
|
||||
handledDelivered.append((senderPubkey, convKey))
|
||||
}
|
||||
|
||||
func handleReadReceipt(_ payload: NoisePayload, senderPubkey: String, convKey: PeerID) {
|
||||
handledReadReceipts.append((senderPubkey, convKey))
|
||||
}
|
||||
|
||||
func startPrivateChat(with peerID: PeerID) { startedPrivateChats.append(peerID) }
|
||||
|
||||
// Nostr identity & blocking
|
||||
var geohashIdentities: [String: NostrIdentity] = [:]
|
||||
var nostrIdentity: NostrIdentity?
|
||||
var blockedNostrPubkeys: Set<String> = []
|
||||
var displayNamesByPubkey: [String: String] = [:]
|
||||
|
||||
private struct NoIdentity: Error {}
|
||||
|
||||
func deriveNostrIdentity(forGeohash geohash: String) throws -> NostrIdentity {
|
||||
guard let identity = geohashIdentities[geohash] else { throw NoIdentity() }
|
||||
return identity
|
||||
}
|
||||
|
||||
func currentNostrIdentity() -> NostrIdentity? { nostrIdentity }
|
||||
|
||||
func isNostrBlocked(pubkeyHexLowercased: String) -> Bool {
|
||||
blockedNostrPubkeys.contains(pubkeyHexLowercased.lowercased())
|
||||
}
|
||||
|
||||
func displayNameForNostrPubkey(_ pubkeyHex: String) -> String {
|
||||
displayNamesByPubkey[pubkeyHex] ?? "anon"
|
||||
}
|
||||
|
||||
// Event dedup
|
||||
private(set) var recordedNostrEventIDs: [String] = []
|
||||
private var processedNostrEventIDs: Set<String> = []
|
||||
private(set) var clearProcessedNostrEventsCount = 0
|
||||
|
||||
func hasProcessedNostrEvent(_ eventID: String) -> Bool { processedNostrEventIDs.contains(eventID) }
|
||||
|
||||
func recordProcessedNostrEvent(_ eventID: String) {
|
||||
processedNostrEventIDs.insert(eventID)
|
||||
recordedNostrEventIDs.append(eventID)
|
||||
}
|
||||
|
||||
func clearProcessedNostrEvents() {
|
||||
processedNostrEventIDs.removeAll()
|
||||
clearProcessedNostrEventsCount += 1
|
||||
}
|
||||
|
||||
// Geo participants & presence
|
||||
var geoNicknames: [String: String] = [:]
|
||||
private(set) var teleportedKeys: Set<String> = []
|
||||
var teleportedGeoCount: Int { teleportedKeys.count }
|
||||
private(set) var refreshTimerStartCount = 0
|
||||
private(set) var refreshTimerStopCount = 0
|
||||
private(set) var activeParticipantGeohashes: [String?] = []
|
||||
private(set) var recordedParticipants: [String] = []
|
||||
private(set) var recordedSampledParticipants: [(pubkeyHex: String, geohash: String)] = []
|
||||
private(set) var clearTeleportedGeoCount = 0
|
||||
private(set) var clearGeoNicknamesCount = 0
|
||||
var visiblePeople: [GeoPerson] = []
|
||||
|
||||
func startGeoParticipantRefreshTimer() { refreshTimerStartCount += 1 }
|
||||
func stopGeoParticipantRefreshTimer() { refreshTimerStopCount += 1 }
|
||||
func setActiveParticipantGeohash(_ geohash: String?) { activeParticipantGeohashes.append(geohash) }
|
||||
func recordGeoParticipant(pubkeyHex: String) { recordedParticipants.append(pubkeyHex) }
|
||||
|
||||
func recordGeoParticipant(pubkeyHex: String, geohash: String) {
|
||||
recordedSampledParticipants.append((pubkeyHex, geohash))
|
||||
}
|
||||
|
||||
func geoParticipantCount(for geohash: String) -> Int {
|
||||
recordedSampledParticipants.filter { $0.geohash == geohash }.count
|
||||
}
|
||||
|
||||
func setGeoNickname(_ nickname: String, forPubkey pubkeyHex: String) { geoNicknames[pubkeyHex.lowercased()] = nickname }
|
||||
func markGeoTeleported(_ pubkeyHexLowercased: String) { teleportedKeys.insert(pubkeyHexLowercased) }
|
||||
func clearGeoTeleported(_ pubkeyHexLowercased: String) { teleportedKeys.remove(pubkeyHexLowercased) }
|
||||
|
||||
func clearTeleportedGeo() {
|
||||
teleportedKeys.removeAll()
|
||||
clearTeleportedGeoCount += 1
|
||||
}
|
||||
|
||||
func clearGeoNicknames() {
|
||||
geoNicknames.removeAll()
|
||||
clearGeoNicknamesCount += 1
|
||||
}
|
||||
|
||||
func visibleGeohashPeople() -> [GeoPerson] { visiblePeople }
|
||||
|
||||
// Location channels
|
||||
var isTeleported = false
|
||||
var regionalGeohashes: Set<String> = []
|
||||
|
||||
func isGeohashOutsideRegionalChannels(_ geohash: String) -> Bool {
|
||||
!regionalGeohashes.isEmpty && !regionalGeohashes.contains(geohash)
|
||||
}
|
||||
|
||||
// Routing & acknowledgements
|
||||
private(set) var routedFavoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
|
||||
private(set) var geoDeliveryAcks: [(messageID: String, recipientHex: String)] = []
|
||||
private(set) var geoReadReceipts: [(messageID: String, recipientHex: String)] = []
|
||||
|
||||
func routeFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
|
||||
routedFavoriteNotifications.append((peerID, isFavorite))
|
||||
}
|
||||
|
||||
func sendGeohashDeliveryAck(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
|
||||
geoDeliveryAcks.append((messageID, recipientHex))
|
||||
}
|
||||
|
||||
func sendGeohashReadReceipt(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
|
||||
geoReadReceipts.append((messageID, recipientHex))
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Helpers
|
||||
|
||||
/// Let the inner `Task { @MainActor in ... }` hops the coordinator schedules
|
||||
/// run to completion.
|
||||
@MainActor
|
||||
private func drainMainQueue() async {
|
||||
for _ in 0..<5 {
|
||||
await Task.yield()
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Coordinator Tests Against Mock Context
|
||||
|
||||
/// Exercises `ChatNostrCoordinator` against `MockChatNostrContext` with no
|
||||
/// `ChatViewModel`. Scoped to the inbound event pipeline (dedup, presence,
|
||||
/// public-message ingest), gift-wrap DM ingest, key mapping, channel-switch
|
||||
/// teardown, and embedded ack flows. Flows that hit live singletons
|
||||
/// (`NostrRelayManager.shared` subscriptions, `TorManager`,
|
||||
/// `FavoritesPersistenceService`) remain covered by the full view-model tests.
|
||||
struct ChatNostrCoordinatorContextTests {
|
||||
|
||||
@Test @MainActor
|
||||
func handleNostrEvent_ingestsPublicMessageOnceAndDeduplicates() async throws {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
|
||||
let sender = try NostrIdentity.generate()
|
||||
let event = try NostrProtocol.createEphemeralGeohashEvent(
|
||||
content: "hello geohash",
|
||||
geohash: "u4pruyd",
|
||||
senderIdentity: sender,
|
||||
nickname: "alice"
|
||||
)
|
||||
context.displayNamesByPubkey[event.pubkey] = "alice#1234"
|
||||
|
||||
coordinator.handleNostrEvent(event)
|
||||
await drainMainQueue()
|
||||
|
||||
// Dedup recorded exactly once, presence and key mapping updated.
|
||||
#expect(context.recordedNostrEventIDs == [event.id])
|
||||
#expect(context.geoNicknames[event.pubkey.lowercased()] == "alice")
|
||||
#expect(context.recordedParticipants == [event.pubkey])
|
||||
#expect(context.nostrKeyMapping[PeerID(nostr: event.pubkey)] == event.pubkey)
|
||||
#expect(context.nostrKeyMapping[PeerID(nostr_: event.pubkey)] == event.pubkey)
|
||||
|
||||
// The message reached the public ingest path with the resolved name.
|
||||
#expect(context.handledPublicMessages.map(\.id) == [event.id])
|
||||
#expect(context.handledPublicMessages.first?.sender == "alice#1234")
|
||||
#expect(context.handledPublicMessages.first?.content == "hello geohash")
|
||||
#expect(context.mentionCheckedMessageIDs == [event.id])
|
||||
#expect(context.hapticMessageIDs == [event.id])
|
||||
|
||||
// A replay of the same event is dropped before any processing.
|
||||
coordinator.handleNostrEvent(event)
|
||||
await drainMainQueue()
|
||||
#expect(context.recordedNostrEventIDs == [event.id])
|
||||
#expect(context.handledPublicMessages.count == 1)
|
||||
#expect(context.recordedParticipants.count == 1)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handleNostrEvent_marksTeleportedPeerWithoutIngestingEmptyContent() async throws {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
|
||||
let sender = try NostrIdentity.generate()
|
||||
let event = try NostrProtocol.createEphemeralGeohashEvent(
|
||||
content: "",
|
||||
geohash: "u4pruyd",
|
||||
senderIdentity: sender,
|
||||
teleported: true
|
||||
)
|
||||
|
||||
coordinator.handleNostrEvent(event)
|
||||
await drainMainQueue()
|
||||
|
||||
// Teleport detection fires even though the empty message is dropped.
|
||||
#expect(context.teleportedKeys == [event.pubkey.lowercased()])
|
||||
#expect(context.recordedParticipants == [event.pubkey])
|
||||
#expect(context.handledPublicMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handleNostrEvent_skipsBlockedSender() async throws {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
|
||||
let sender = try NostrIdentity.generate()
|
||||
let event = try NostrProtocol.createEphemeralGeohashEvent(
|
||||
content: "spam",
|
||||
geohash: "u4pruyd",
|
||||
senderIdentity: sender
|
||||
)
|
||||
context.blockedNostrPubkeys.insert(event.pubkey.lowercased())
|
||||
|
||||
coordinator.handleNostrEvent(event)
|
||||
await drainMainQueue()
|
||||
|
||||
// The event is still recorded for dedup but nothing else happens.
|
||||
#expect(context.recordedNostrEventIDs == [event.id])
|
||||
#expect(context.recordedParticipants.isEmpty)
|
||||
#expect(context.handledPublicMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handleGiftWrap_routesEmbeddedPrivateMessageAndDeduplicates() async throws {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
|
||||
let recipient = try NostrIdentity.generate()
|
||||
let sender = try NostrIdentity.generate()
|
||||
let embedded = try #require(NostrEmbeddedBitChat.encodePMForNostrNoRecipient(
|
||||
content: "psst",
|
||||
messageID: "gm-1",
|
||||
senderPeerID: PeerID(str: "aabbccddeeff0011")
|
||||
))
|
||||
let giftWrap = try NostrProtocol.createPrivateMessage(
|
||||
content: embedded,
|
||||
recipientPubkey: recipient.publicKeyHex,
|
||||
senderIdentity: sender
|
||||
)
|
||||
|
||||
coordinator.handleGiftWrap(giftWrap, id: recipient)
|
||||
|
||||
let convKey = PeerID(nostr_: sender.publicKeyHex)
|
||||
#expect(context.recordedNostrEventIDs == [giftWrap.id])
|
||||
#expect(context.nostrKeyMapping[convKey] == sender.publicKeyHex)
|
||||
#expect(context.handledPrivateMessages.count == 1)
|
||||
#expect(context.handledPrivateMessages.first?.senderPubkey == sender.publicKeyHex)
|
||||
#expect(context.handledPrivateMessages.first?.convKey == convKey)
|
||||
|
||||
// The embedded Noise payload survives the round trip intact.
|
||||
let payload = try #require(context.handledPrivateMessages.first?.payload)
|
||||
#expect(payload.type == .privateMessage)
|
||||
let pm = try #require(PrivateMessagePacket.decode(from: payload.data))
|
||||
#expect(pm.messageID == "gm-1")
|
||||
#expect(pm.content == "psst")
|
||||
|
||||
// The same gift wrap is dropped on replay.
|
||||
coordinator.handleGiftWrap(giftWrap, id: recipient)
|
||||
#expect(context.recordedNostrEventIDs == [giftWrap.id])
|
||||
#expect(context.handledPrivateMessages.count == 1)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func switchLocationChannel_toMesh_tearsDownGeohashState() async {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
context.activeChannel = .mesh
|
||||
context.currentGeohash = "u4pruyd"
|
||||
context.geoNicknames = ["abcd": "alice"]
|
||||
|
||||
coordinator.switchLocationChannel(to: .mesh)
|
||||
|
||||
#expect(context.pipelineResetCount == 1)
|
||||
#expect(context.activeChannel == .mesh)
|
||||
#expect(context.pipelineChannelUpdates == [.mesh])
|
||||
#expect(context.clearProcessedNostrEventsCount == 1)
|
||||
#expect(context.refreshedChannels == [.mesh])
|
||||
#expect(context.refreshTimerStopCount == 1)
|
||||
#expect(context.clearTeleportedGeoCount == 1)
|
||||
// Cleared once in the mesh branch, once in the shared teardown.
|
||||
#expect(context.activeParticipantGeohashes == [nil, nil])
|
||||
#expect(context.currentGeohash == nil)
|
||||
#expect(context.geoSubscriptionID == nil)
|
||||
#expect(context.geoDmSubscriptionID == nil)
|
||||
#expect(context.clearGeoNicknamesCount == 1)
|
||||
#expect(context.geoNicknames.isEmpty)
|
||||
// Mesh never starts a geohash subscription or refresh timer.
|
||||
#expect(context.refreshTimerStartCount == 0)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func sendDeliveryAckViaNostrEmbedded_sendsReadReceiptOnlyWhenViewingUnread() async throws {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
context.nostrIdentity = try NostrIdentity.generate()
|
||||
let senderPubkey = "feedface00112233"
|
||||
let convKey = PeerID(nostr_: senderPubkey)
|
||||
|
||||
let message = BitchatMessage(
|
||||
id: "mid-1",
|
||||
sender: "alice#1234",
|
||||
content: "hi",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "me",
|
||||
senderPeerID: convKey
|
||||
)
|
||||
|
||||
// Not viewing the chat: delivery ack only.
|
||||
coordinator.sendDeliveryAckViaNostrEmbedded(message, wasReadBefore: false, senderPubkey: senderPubkey, key: nil)
|
||||
#expect(context.geoDeliveryAcks.map(\.messageID) == ["mid-1"])
|
||||
#expect(context.geoDeliveryAcks.first?.recipientHex == senderPubkey)
|
||||
#expect(context.geoReadReceipts.isEmpty)
|
||||
|
||||
// Viewing the chat: delivery ack plus read receipt.
|
||||
context.selectedPrivateChatPeer = convKey
|
||||
coordinator.sendDeliveryAckViaNostrEmbedded(message, wasReadBefore: false, senderPubkey: senderPubkey, key: Data([0x01]))
|
||||
#expect(context.geoDeliveryAcks.count == 2)
|
||||
#expect(context.geoReadReceipts.map(\.messageID) == ["mid-1"])
|
||||
|
||||
// Already read: no further read receipt.
|
||||
coordinator.sendDeliveryAckViaNostrEmbedded(message, wasReadBefore: true, senderPubkey: senderPubkey, key: nil)
|
||||
#expect(context.geoDeliveryAcks.count == 3)
|
||||
#expect(context.geoReadReceipts.count == 1)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func geohashDMKeyMappingHelpers_resolveAndStartChats() async {
|
||||
let context = MockChatNostrContext()
|
||||
let coordinator = ChatNostrCoordinator(context: context)
|
||||
let hex = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
|
||||
let convKey = PeerID(nostr_: hex)
|
||||
context.displayNamesByPubkey[hex] = "bob#eeff"
|
||||
|
||||
coordinator.startGeohashDM(withPubkeyHex: hex)
|
||||
#expect(context.nostrKeyMapping[convKey] == hex)
|
||||
#expect(context.startedPrivateChats == [convKey])
|
||||
|
||||
#expect(coordinator.fullNostrHex(forSenderPeerID: convKey) == hex)
|
||||
#expect(coordinator.geohashDisplayName(for: convKey) == "bob#eeff")
|
||||
|
||||
// Unmapped conversation keys fall back to the bare peer ID.
|
||||
let unknown = PeerID(nostr_: "ffeeddccbbaa99887766554433221100ffeeddccbbaa99887766554433221100")
|
||||
#expect(coordinator.geohashDisplayName(for: unknown) == unknown.bare)
|
||||
|
||||
// Display-name lookup prefers visible people, then nicknames.
|
||||
context.visiblePeople = [GeoPerson(id: "aa11", displayName: "carol#aa11", lastSeen: Date())]
|
||||
context.geoNicknames = ["bb22": "dave"]
|
||||
#expect(coordinator.nostrPubkeyForDisplayName("carol#aa11") == "aa11")
|
||||
#expect(coordinator.nostrPubkeyForDisplayName("dave") == "bb22")
|
||||
#expect(coordinator.nostrPubkeyForDisplayName("nobody") == nil)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,390 @@
|
||||
//
|
||||
// ChatPrivateConversationCoordinatorContextTests.swift
|
||||
// bitchatTests
|
||||
//
|
||||
// Exercises `ChatPrivateConversationCoordinator` against a mock
|
||||
// `ChatPrivateConversationContext` — proving the coordinator works without a
|
||||
// `ChatViewModel`, following the `ChatDeliveryCoordinatorContextTests` exemplar.
|
||||
//
|
||||
|
||||
import Testing
|
||||
import Foundation
|
||||
import BitFoundation
|
||||
@testable import bitchat
|
||||
|
||||
// MARK: - Mock Context
|
||||
|
||||
/// Lightweight stand-in for `ChatPrivateConversationContext` proving that
|
||||
/// `ChatPrivateConversationCoordinator` is testable without a `ChatViewModel`.
|
||||
@MainActor
|
||||
private final class MockChatPrivateConversationContext: ChatPrivateConversationContext {
|
||||
// Conversation state
|
||||
var privateChats: [PeerID: [BitchatMessage]] = [:]
|
||||
var sentReadReceipts: Set<String> = []
|
||||
var sentGeoDeliveryAcks: Set<String> = []
|
||||
var unreadPrivateMessages: Set<PeerID> = []
|
||||
var selectedPrivateChatPeer: PeerID?
|
||||
var nickname = "me"
|
||||
var activeChannel: ChannelID = .mesh
|
||||
var nostrKeyMapping: [PeerID: String] = [:]
|
||||
private(set) var notifyUIChangedCount = 0
|
||||
|
||||
func notifyUIChanged() {
|
||||
notifyUIChangedCount += 1
|
||||
}
|
||||
|
||||
// Peers & identity
|
||||
var myPeerID = PeerID(str: "0011223344556677")
|
||||
var nicknamesByPeerID: [PeerID: String] = [:]
|
||||
var connectedPeers: Set<PeerID> = []
|
||||
var reachablePeers: Set<PeerID> = []
|
||||
var blockedPeers: Set<PeerID> = []
|
||||
var noiseKeysByPeerID: [PeerID: Data] = [:]
|
||||
var ephemeralPeerIDsByNoiseKey: [Data: PeerID] = [:]
|
||||
var peerIDsByNickname: [String: PeerID] = [:]
|
||||
var fingerprintsByPeerID: [PeerID: String] = [:]
|
||||
private(set) var clearedFingerprints: [PeerID] = []
|
||||
|
||||
func peerNickname(for peerID: PeerID) -> String? { nicknamesByPeerID[peerID] }
|
||||
func isPeerConnected(_ peerID: PeerID) -> Bool { connectedPeers.contains(peerID) }
|
||||
func isPeerReachable(_ peerID: PeerID) -> Bool { reachablePeers.contains(peerID) }
|
||||
func isPeerBlocked(_ peerID: PeerID) -> Bool { blockedPeers.contains(peerID) }
|
||||
func noisePublicKey(for peerID: PeerID) -> Data? { noiseKeysByPeerID[peerID] }
|
||||
func ephemeralPeerID(forNoiseKey noiseKey: Data) -> PeerID? { ephemeralPeerIDsByNoiseKey[noiseKey] }
|
||||
func getPeerIDForNickname(_ nickname: String) -> PeerID? { peerIDsByNickname[nickname] }
|
||||
func getFingerprint(for peerID: PeerID) -> String? { fingerprintsByPeerID[peerID] }
|
||||
func storedFingerprint(for peerID: PeerID) -> String? { fingerprintsByPeerID[peerID] }
|
||||
|
||||
func clearStoredFingerprint(for peerID: PeerID) {
|
||||
fingerprintsByPeerID.removeValue(forKey: peerID)
|
||||
clearedFingerprints.append(peerID)
|
||||
}
|
||||
|
||||
// Nostr identity
|
||||
var blockedNostrPubkeys: Set<String> = []
|
||||
var displayNamesByPubkey: [String: String] = [:]
|
||||
|
||||
func isNostrBlocked(pubkeyHexLowercased: String) -> Bool {
|
||||
blockedNostrPubkeys.contains(pubkeyHexLowercased)
|
||||
}
|
||||
|
||||
func displayNameForNostrPubkey(_ pubkeyHex: String) -> String {
|
||||
displayNamesByPubkey[pubkeyHex] ?? "anon"
|
||||
}
|
||||
|
||||
func deriveNostrIdentity(forGeohash geohash: String) throws -> NostrIdentity { Self.dummyIdentity }
|
||||
func currentNostrIdentity() -> NostrIdentity? { Self.dummyIdentity }
|
||||
|
||||
// Routing & acknowledgements
|
||||
private(set) var routedPrivateMessages: [(content: String, peerID: PeerID, messageID: String)] = []
|
||||
private(set) var routedReadReceipts: [(messageID: String, peerID: PeerID)] = []
|
||||
private(set) var routedFavoriteNotifications: [(peerID: PeerID, isFavorite: Bool)] = []
|
||||
private(set) var meshReadReceipts: [(messageID: String, peerID: PeerID)] = []
|
||||
private(set) var geoPrivateMessages: [(content: String, recipientHex: String, messageID: String)] = []
|
||||
private(set) var geoDeliveryAcks: [(messageID: String, recipientHex: String)] = []
|
||||
private(set) var geoReadReceipts: [(messageID: String, recipientHex: String)] = []
|
||||
private(set) var embeddedDeliveryAckMessageIDs: [String] = []
|
||||
|
||||
func routePrivateMessage(_ content: String, to peerID: PeerID, recipientNickname: String, messageID: String) {
|
||||
routedPrivateMessages.append((content, peerID, messageID))
|
||||
}
|
||||
|
||||
func routeReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
|
||||
routedReadReceipts.append((receipt.originalMessageID, peerID))
|
||||
}
|
||||
|
||||
func routeFavoriteNotification(to peerID: PeerID, isFavorite: Bool) {
|
||||
routedFavoriteNotifications.append((peerID, isFavorite))
|
||||
}
|
||||
|
||||
func sendMeshReadReceipt(_ receipt: ReadReceipt, to peerID: PeerID) {
|
||||
meshReadReceipts.append((receipt.originalMessageID, peerID))
|
||||
}
|
||||
|
||||
func sendGeohashPrivateMessage(_ content: String, toRecipientHex recipientHex: String, from identity: NostrIdentity, messageID: String) {
|
||||
geoPrivateMessages.append((content, recipientHex, messageID))
|
||||
}
|
||||
|
||||
func sendGeohashDeliveryAck(for messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
|
||||
geoDeliveryAcks.append((messageID, recipientHex))
|
||||
}
|
||||
|
||||
func sendGeohashReadReceipt(_ messageID: String, toRecipientHex recipientHex: String, from identity: NostrIdentity) {
|
||||
geoReadReceipts.append((messageID, recipientHex))
|
||||
}
|
||||
|
||||
func sendDeliveryAckViaNostrEmbedded(_ message: BitchatMessage, wasReadBefore: Bool, senderPubkey: String, key: Data?) {
|
||||
embeddedDeliveryAckMessageIDs.append(message.id)
|
||||
}
|
||||
|
||||
// System messages & chat hygiene
|
||||
private(set) var systemMessages: [String] = []
|
||||
private(set) var meshOnlySystemMessages: [String] = []
|
||||
private(set) var sanitizedPeerIDs: [PeerID] = []
|
||||
|
||||
func addSystemMessage(_ content: String) {
|
||||
systemMessages.append(content)
|
||||
}
|
||||
|
||||
func addMeshOnlySystemMessage(_ content: String) {
|
||||
meshOnlySystemMessages.append(content)
|
||||
}
|
||||
|
||||
func sanitizeChat(for peerID: PeerID) {
|
||||
sanitizedPeerIDs.append(peerID)
|
||||
}
|
||||
|
||||
static let dummyIdentity = NostrIdentity(
|
||||
privateKey: Data(repeating: 0x11, count: 32),
|
||||
publicKey: Data(repeating: 0x22, count: 32),
|
||||
npub: "npub1mock",
|
||||
createdAt: Date(timeIntervalSince1970: 0)
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Helpers
|
||||
|
||||
@MainActor
|
||||
private func makeIncomingMessage(
|
||||
id: String,
|
||||
sender: String = "alice",
|
||||
content: String = "hello",
|
||||
timestamp: Date = Date(),
|
||||
senderPeerID: PeerID? = nil,
|
||||
recipientNickname: String? = "me"
|
||||
) -> BitchatMessage {
|
||||
BitchatMessage(
|
||||
id: id,
|
||||
sender: sender,
|
||||
content: content,
|
||||
timestamp: timestamp,
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: recipientNickname,
|
||||
senderPeerID: senderPeerID,
|
||||
deliveryStatus: .delivered(to: "me", at: timestamp)
|
||||
)
|
||||
}
|
||||
|
||||
private func isDelivered(_ status: DeliveryStatus?, to expected: String) -> Bool {
|
||||
if case .delivered(let to, _) = status { return to == expected }
|
||||
return false
|
||||
}
|
||||
|
||||
private func isRead(_ status: DeliveryStatus?, by expected: String) -> Bool {
|
||||
if case .read(let by, _) = status { return by == expected }
|
||||
return false
|
||||
}
|
||||
|
||||
// MARK: - Coordinator Tests Against Mock Context
|
||||
|
||||
/// Exercises `ChatPrivateConversationCoordinator` against
|
||||
/// `MockChatPrivateConversationContext` with no `ChatViewModel`. Scoped to the
|
||||
/// pure-state and ack flows; flows that hit `NotificationService` /
|
||||
/// `FavoritesPersistenceService` singletons remain covered by the full
|
||||
/// view-model tests.
|
||||
struct ChatPrivateConversationCoordinatorContextTests {
|
||||
|
||||
@Test @MainActor
|
||||
func addMessageToPrivateChats_upsertsByIdAndSanitizes() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
|
||||
let original = makeIncomingMessage(id: "m1", content: "first")
|
||||
coordinator.addMessageToPrivateChatsIfNeeded(original, targetPeerID: peerID)
|
||||
#expect(context.privateChats[peerID]?.map(\.id) == ["m1"])
|
||||
|
||||
// Same id again must replace in place, not append a duplicate.
|
||||
let updated = makeIncomingMessage(id: "m1", content: "edited")
|
||||
coordinator.addMessageToPrivateChatsIfNeeded(updated, targetPeerID: peerID)
|
||||
#expect(context.privateChats[peerID]?.count == 1)
|
||||
#expect(context.privateChats[peerID]?.first?.content == "edited")
|
||||
|
||||
// A different id appends.
|
||||
coordinator.addMessageToPrivateChatsIfNeeded(makeIncomingMessage(id: "m2"), targetPeerID: peerID)
|
||||
#expect(context.privateChats[peerID]?.map(\.id) == ["m1", "m2"])
|
||||
#expect(context.sanitizedPeerIDs == [peerID, peerID, peerID])
|
||||
|
||||
#expect(coordinator.isDuplicateMessage("m1", targetPeerID: peerID))
|
||||
#expect(!coordinator.isDuplicateMessage("m3", targetPeerID: peerID))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func geoDeliveredAndReadAcks_updateStatusAndNotify() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let convKey = PeerID(str: "nostr_abcdef12")
|
||||
let senderPubkey = "feedface00112233"
|
||||
context.displayNamesByPubkey[senderPubkey] = "alice#1234"
|
||||
context.privateChats[convKey] = [
|
||||
makeIncomingMessage(id: "mine-1", sender: "me"),
|
||||
makeIncomingMessage(id: "mine-2", sender: "me"),
|
||||
]
|
||||
|
||||
coordinator.handleDelivered(
|
||||
NoisePayload(type: .delivered, data: Data("mine-1".utf8)),
|
||||
senderPubkey: senderPubkey,
|
||||
convKey: convKey
|
||||
)
|
||||
#expect(isDelivered(context.privateChats[convKey]?.first?.deliveryStatus, to: "alice#1234"))
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
|
||||
coordinator.handleReadReceipt(
|
||||
NoisePayload(type: .readReceipt, data: Data("mine-2".utf8)),
|
||||
senderPubkey: senderPubkey,
|
||||
convKey: convKey
|
||||
)
|
||||
#expect(isRead(context.privateChats[convKey]?.last?.deliveryStatus, by: "alice#1234"))
|
||||
#expect(context.notifyUIChangedCount == 2)
|
||||
|
||||
// Unknown message id: no state change, no UI notification.
|
||||
coordinator.handleDelivered(
|
||||
NoisePayload(type: .delivered, data: Data("missing".utf8)),
|
||||
senderPubkey: senderPubkey,
|
||||
convKey: convKey
|
||||
)
|
||||
#expect(context.notifyUIChangedCount == 2)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func geoPrivateMessage_sendsDeliveryAckOnceAndDeduplicates() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let convKey = PeerID(str: "nostr_abcdef12")
|
||||
let senderPubkey = "feedface00112233"
|
||||
context.displayNamesByPubkey[senderPubkey] = "bob#5678"
|
||||
let payloadData = PrivateMessagePacket(messageID: "geo-1", content: "hi there").encode()!
|
||||
let payload = NoisePayload(type: .privateMessage, data: payloadData)
|
||||
// Old timestamp: not "recent", so no unread marking (and no notification).
|
||||
let oldTimestamp = Date().addingTimeInterval(-120)
|
||||
|
||||
coordinator.handlePrivateMessage(
|
||||
payload,
|
||||
senderPubkey: senderPubkey,
|
||||
convKey: convKey,
|
||||
id: MockChatPrivateConversationContext.dummyIdentity,
|
||||
messageTimestamp: oldTimestamp
|
||||
)
|
||||
|
||||
#expect(context.geoDeliveryAcks.map(\.messageID) == ["geo-1"])
|
||||
#expect(context.geoDeliveryAcks.first?.recipientHex == senderPubkey)
|
||||
#expect(context.sentGeoDeliveryAcks == ["geo-1"])
|
||||
#expect(context.privateChats[convKey]?.map(\.id) == ["geo-1"])
|
||||
#expect(context.privateChats[convKey]?.first?.sender == "bob#5678")
|
||||
#expect(context.unreadPrivateMessages.isEmpty)
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
|
||||
// Redelivery: ack is deduplicated and the message is not appended twice.
|
||||
coordinator.handlePrivateMessage(
|
||||
payload,
|
||||
senderPubkey: senderPubkey,
|
||||
convKey: convKey,
|
||||
id: MockChatPrivateConversationContext.dummyIdentity,
|
||||
messageTimestamp: oldTimestamp
|
||||
)
|
||||
#expect(context.geoDeliveryAcks.count == 1)
|
||||
#expect(context.privateChats[convKey]?.count == 1)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handleViewingThisChat_clearsUnreadAndSendsRoutedReadReceiptOnce() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let noiseKey = Data(repeating: 0xAB, count: 32)
|
||||
let stablePeerID = PeerID(hexData: noiseKey)
|
||||
let ephemeralPeerID = PeerID(str: "0102030405060708")
|
||||
context.ephemeralPeerIDsByNoiseKey[noiseKey] = ephemeralPeerID
|
||||
context.unreadPrivateMessages = [stablePeerID, ephemeralPeerID]
|
||||
let message = makeIncomingMessage(id: "read-1", senderPeerID: stablePeerID)
|
||||
|
||||
coordinator.handleViewingThisChat(
|
||||
message,
|
||||
targetPeerID: stablePeerID,
|
||||
key: noiseKey,
|
||||
senderPubkey: "feedface00112233"
|
||||
)
|
||||
|
||||
#expect(context.unreadPrivateMessages.isEmpty)
|
||||
#expect(context.routedReadReceipts.map(\.messageID) == ["read-1"])
|
||||
#expect(context.routedReadReceipts.first?.peerID == stablePeerID)
|
||||
#expect(context.sentReadReceipts == ["read-1"])
|
||||
|
||||
// Already-acked message must not produce a second receipt.
|
||||
coordinator.handleViewingThisChat(
|
||||
message,
|
||||
targetPeerID: stablePeerID,
|
||||
key: noiseKey,
|
||||
senderPubkey: "feedface00112233"
|
||||
)
|
||||
#expect(context.routedReadReceipts.count == 1)
|
||||
|
||||
// Without a Noise key, the receipt goes out via the geohash transport.
|
||||
context.sentReadReceipts = []
|
||||
coordinator.handleViewingThisChat(
|
||||
message,
|
||||
targetPeerID: stablePeerID,
|
||||
key: nil,
|
||||
senderPubkey: "feedface00112233"
|
||||
)
|
||||
#expect(context.geoReadReceipts.map(\.messageID) == ["read-1"])
|
||||
#expect(context.sentReadReceipts == ["read-1"])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func markAsUnread_tracksTargetAndEphemeralWithoutNotificationWhenStale() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let noiseKey = Data(repeating: 0xCD, count: 32)
|
||||
let stablePeerID = PeerID(hexData: noiseKey)
|
||||
let ephemeralPeerID = PeerID(str: "1112131415161718")
|
||||
context.ephemeralPeerIDsByNoiseKey[noiseKey] = ephemeralPeerID
|
||||
|
||||
// isRecentMessage false keeps the flow off the NotificationService singleton.
|
||||
coordinator.markAsUnreadIfNeeded(
|
||||
shouldMarkAsUnread: true,
|
||||
targetPeerID: stablePeerID,
|
||||
key: noiseKey,
|
||||
isRecentMessage: false,
|
||||
senderNickname: "alice",
|
||||
messageContent: "hello"
|
||||
)
|
||||
#expect(context.unreadPrivateMessages == [stablePeerID, ephemeralPeerID])
|
||||
|
||||
context.unreadPrivateMessages = []
|
||||
coordinator.markAsUnreadIfNeeded(
|
||||
shouldMarkAsUnread: false,
|
||||
targetPeerID: stablePeerID,
|
||||
key: noiseKey,
|
||||
isRecentMessage: false,
|
||||
senderNickname: "alice",
|
||||
messageContent: "hello"
|
||||
)
|
||||
#expect(context.unreadPrivateMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func migratePrivateChats_movesMessagesOnFingerprintMatchAndClearsOldPeer() async {
|
||||
let context = MockChatPrivateConversationContext()
|
||||
let coordinator = ChatPrivateConversationCoordinator(context: context)
|
||||
let oldPeerID = PeerID(str: "aaaaaaaaaaaaaaaa")
|
||||
let newPeerID = PeerID(str: "bbbbbbbbbbbbbbbb")
|
||||
context.fingerprintsByPeerID[oldPeerID] = "fp-1"
|
||||
context.fingerprintsByPeerID[newPeerID] = "fp-1"
|
||||
let older = makeIncomingMessage(id: "old-1", timestamp: Date().addingTimeInterval(-60))
|
||||
let newer = makeIncomingMessage(id: "old-2", timestamp: Date().addingTimeInterval(-30))
|
||||
context.privateChats[oldPeerID] = [newer, older]
|
||||
context.unreadPrivateMessages = [oldPeerID]
|
||||
context.selectedPrivateChatPeer = oldPeerID
|
||||
|
||||
coordinator.migratePrivateChatsIfNeeded(for: newPeerID, senderNickname: "alice")
|
||||
|
||||
#expect(context.privateChats[oldPeerID] == nil)
|
||||
#expect(context.privateChats[newPeerID]?.map(\.id) == ["old-1", "old-2"])
|
||||
#expect(context.unreadPrivateMessages.isEmpty)
|
||||
#expect(context.clearedFingerprints == [oldPeerID])
|
||||
#expect(context.selectedPrivateChatPeer == newPeerID)
|
||||
#expect(context.sanitizedPeerIDs == [newPeerID])
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,495 @@
|
||||
//
|
||||
// ChatPublicConversationCoordinatorContextTests.swift
|
||||
// bitchatTests
|
||||
//
|
||||
// Exercises `ChatPublicConversationCoordinator` against a mock
|
||||
// `ChatPublicConversationContext` — proving the coordinator works without a
|
||||
// `ChatViewModel`, following the `ChatDeliveryCoordinatorContextTests` /
|
||||
// `ChatPrivateConversationCoordinatorContextTests` exemplars.
|
||||
//
|
||||
// Scope note: flows that hit process-wide singletons are intentionally not
|
||||
// exercised here — `checkForMentions` / haptics (NotificationService.shared,
|
||||
// UIApplication) and the geohash branch of `sendPublicRaw`
|
||||
// (NostrRelayManager.shared, GeoRelayDirectory.shared). The mesh branch of
|
||||
// `sendPublicRaw` and all timeline/store/blocking flows are covered.
|
||||
//
|
||||
|
||||
import Testing
|
||||
import Foundation
|
||||
import BitFoundation
|
||||
@testable import bitchat
|
||||
|
||||
// MARK: - Mock Context
|
||||
|
||||
/// Lightweight stand-in for `ChatPublicConversationContext` proving that
|
||||
/// `ChatPublicConversationCoordinator` is testable without a `ChatViewModel`.
|
||||
@MainActor
|
||||
private final class MockChatPublicConversationContext: ChatPublicConversationContext {
|
||||
// Channel & visible timeline state
|
||||
var messages: [BitchatMessage] = []
|
||||
var activeChannel: ChannelID = .mesh
|
||||
var currentGeohash: String?
|
||||
var nickname = "me"
|
||||
var myPeerID = PeerID(str: "0011223344556677")
|
||||
var isBatchingPublic = false
|
||||
private(set) var notifyUIChangedCount = 0
|
||||
private(set) var trimMessagesCount = 0
|
||||
|
||||
func notifyUIChanged() {
|
||||
notifyUIChangedCount += 1
|
||||
}
|
||||
|
||||
func trimMessagesIfNeeded() {
|
||||
trimMessagesCount += 1
|
||||
}
|
||||
|
||||
// Public timeline store
|
||||
var meshTimeline: [BitchatMessage] = []
|
||||
var geoTimelines: [String: [BitchatMessage]] = [:]
|
||||
private(set) var queuedGeohashSystemMessages: [String] = []
|
||||
|
||||
func timelineMessages(for channel: ChannelID) -> [BitchatMessage] {
|
||||
switch channel {
|
||||
case .mesh: return meshTimeline
|
||||
case .location(let channel): return geoTimelines[channel.geohash] ?? []
|
||||
}
|
||||
}
|
||||
|
||||
func appendTimelineMessage(_ message: BitchatMessage, to channel: ChannelID) {
|
||||
switch channel {
|
||||
case .mesh: meshTimeline.append(message)
|
||||
case .location(let channel): geoTimelines[channel.geohash, default: []].append(message)
|
||||
}
|
||||
}
|
||||
|
||||
func appendGeohashMessageIfAbsent(_ message: BitchatMessage, toGeohash geohash: String) -> Bool {
|
||||
if geoTimelines[geohash]?.contains(where: { $0.id == message.id }) == true {
|
||||
return false
|
||||
}
|
||||
geoTimelines[geohash, default: []].append(message)
|
||||
return true
|
||||
}
|
||||
|
||||
func removeTimelineMessage(withID id: String) -> BitchatMessage? {
|
||||
if let index = meshTimeline.firstIndex(where: { $0.id == id }) {
|
||||
return meshTimeline.remove(at: index)
|
||||
}
|
||||
for (geohash, timeline) in geoTimelines {
|
||||
guard let index = timeline.firstIndex(where: { $0.id == id }) else { continue }
|
||||
var updated = timeline
|
||||
let removed = updated.remove(at: index)
|
||||
geoTimelines[geohash] = updated
|
||||
return removed
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func removeGeohashTimelineMessages(in geohash: String, where predicate: (BitchatMessage) -> Bool) {
|
||||
geoTimelines[geohash]?.removeAll(where: predicate)
|
||||
}
|
||||
|
||||
func clearTimeline(for channel: ChannelID) {
|
||||
switch channel {
|
||||
case .mesh: meshTimeline.removeAll()
|
||||
case .location(let channel): geoTimelines[channel.geohash] = []
|
||||
}
|
||||
}
|
||||
|
||||
func timelineGeohashKeys() -> [String] {
|
||||
Array(geoTimelines.keys)
|
||||
}
|
||||
|
||||
func queueGeohashSystemMessage(_ content: String) {
|
||||
queuedGeohashSystemMessages.append(content)
|
||||
}
|
||||
|
||||
// Conversation stores
|
||||
private(set) var conversationActiveChannels: [ChannelID] = []
|
||||
private(set) var replacedChannelMessages: [(channel: ChannelID, messageIDs: [String])] = []
|
||||
private(set) var replacedConversationMessages: [(conversation: ConversationID, messageIDs: [String])] = []
|
||||
private(set) var privateStoreSyncCount = 0
|
||||
private(set) var selectionStoreSyncCount = 0
|
||||
|
||||
func setConversationActiveChannel(_ channel: ChannelID) {
|
||||
conversationActiveChannels.append(channel)
|
||||
}
|
||||
|
||||
func replaceConversationMessages(_ messages: [BitchatMessage], for channelID: ChannelID) {
|
||||
replacedChannelMessages.append((channelID, messages.map(\.id)))
|
||||
}
|
||||
|
||||
func replaceConversationMessages(_ messages: [BitchatMessage], for conversationID: ConversationID) {
|
||||
replacedConversationMessages.append((conversationID, messages.map(\.id)))
|
||||
}
|
||||
|
||||
func synchronizePrivateConversationStore() {
|
||||
privateStoreSyncCount += 1
|
||||
}
|
||||
|
||||
func synchronizeConversationSelectionStore() {
|
||||
selectionStoreSyncCount += 1
|
||||
}
|
||||
|
||||
// Private chats
|
||||
var privateChats: [PeerID: [BitchatMessage]] = [:]
|
||||
var unreadPrivateMessages: Set<PeerID> = []
|
||||
private(set) var cleanedUpFileMessageIDs: [String] = []
|
||||
|
||||
func cleanupLocalFile(forMessage message: BitchatMessage) {
|
||||
cleanedUpFileMessageIDs.append(message.id)
|
||||
}
|
||||
|
||||
// Geohash participants & presence
|
||||
var geoNicknames: [String: String] = [:]
|
||||
var isTeleported = false
|
||||
var nostrKeyMapping: [PeerID: String] = [:]
|
||||
var geoPeople: [GeoPerson] = []
|
||||
var geoParticipantCounts: [String: Int] = [:]
|
||||
private(set) var removedGeoParticipants: [String] = []
|
||||
|
||||
func visibleGeoPeople() -> [GeoPerson] {
|
||||
geoPeople
|
||||
}
|
||||
|
||||
func geoParticipantCount(for geohash: String) -> Int {
|
||||
geoParticipantCounts[geohash] ?? 0
|
||||
}
|
||||
|
||||
func removeGeoParticipant(pubkeyHex: String) {
|
||||
removedGeoParticipants.append(pubkeyHex)
|
||||
}
|
||||
|
||||
// Nostr identity & blocking
|
||||
var blockedNostrPubkeys: Set<String> = []
|
||||
|
||||
func deriveNostrIdentity(forGeohash geohash: String) throws -> NostrIdentity {
|
||||
Self.dummyIdentity
|
||||
}
|
||||
|
||||
func isNostrBlocked(pubkeyHexLowercased: String) -> Bool {
|
||||
blockedNostrPubkeys.contains(pubkeyHexLowercased)
|
||||
}
|
||||
|
||||
func setNostrBlocked(_ pubkeyHexLowercased: String, isBlocked: Bool) {
|
||||
if isBlocked {
|
||||
blockedNostrPubkeys.insert(pubkeyHexLowercased)
|
||||
} else {
|
||||
blockedNostrPubkeys.remove(pubkeyHexLowercased)
|
||||
}
|
||||
}
|
||||
|
||||
// Mesh transport
|
||||
var meshNicknames: [PeerID: String] = [:]
|
||||
private(set) var sentMeshMessages: [(content: String, messageID: String)] = []
|
||||
|
||||
func meshPeerNicknames() -> [PeerID: String] {
|
||||
meshNicknames
|
||||
}
|
||||
|
||||
func sendMeshMessage(_ content: String, mentions: [String], messageID: String, timestamp: Date) {
|
||||
sentMeshMessages.append((content, messageID))
|
||||
}
|
||||
|
||||
// Inbound public message processing
|
||||
var blockedMessageIDs: Set<String> = []
|
||||
var rateLimitAllowed = true
|
||||
private(set) var rateLimitChecks: [(senderKey: String, contentKey: String)] = []
|
||||
private(set) var enqueuedMessageIDs: [String] = []
|
||||
var stablePeerIDs: [PeerID: PeerID] = [:]
|
||||
|
||||
func processActionMessage(_ message: BitchatMessage) -> BitchatMessage {
|
||||
message
|
||||
}
|
||||
|
||||
func isMessageBlocked(_ message: BitchatMessage) -> Bool {
|
||||
blockedMessageIDs.contains(message.id)
|
||||
}
|
||||
|
||||
func allowPublicMessage(senderKey: String, contentKey: String) -> Bool {
|
||||
rateLimitChecks.append((senderKey, contentKey))
|
||||
return rateLimitAllowed
|
||||
}
|
||||
|
||||
func enqueuePublicMessage(_ message: BitchatMessage) {
|
||||
enqueuedMessageIDs.append(message.id)
|
||||
}
|
||||
|
||||
func cachedStablePeerID(for shortPeerID: PeerID) -> PeerID? {
|
||||
stablePeerIDs[shortPeerID]
|
||||
}
|
||||
|
||||
// Content dedup & formatting
|
||||
var contentTimestamps: [String: Date] = [:]
|
||||
private(set) var recordedContentKeys: [(key: String, timestamp: Date)] = []
|
||||
private(set) var prewarmedMessageIDs: [String] = []
|
||||
|
||||
func normalizedContentKey(_ content: String) -> String {
|
||||
content.lowercased()
|
||||
}
|
||||
|
||||
func contentTimestamp(forKey key: String) -> Date? {
|
||||
contentTimestamps[key]
|
||||
}
|
||||
|
||||
func recordContentKey(_ key: String, timestamp: Date) {
|
||||
recordedContentKeys.append((key, timestamp))
|
||||
}
|
||||
|
||||
func prewarmMessageFormatting(_ message: BitchatMessage) {
|
||||
prewarmedMessageIDs.append(message.id)
|
||||
}
|
||||
|
||||
static let dummyIdentity = NostrIdentity(
|
||||
privateKey: Data(repeating: 0x11, count: 32),
|
||||
publicKey: Data(repeating: 0x22, count: 32),
|
||||
npub: "npub1mock",
|
||||
createdAt: Date(timeIntervalSince1970: 0)
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Helpers
|
||||
|
||||
@MainActor
|
||||
private func makePublicMessage(
|
||||
id: String = UUID().uuidString,
|
||||
sender: String = "alice",
|
||||
content: String = "hello world",
|
||||
senderPeerID: PeerID? = PeerID(str: "aabbccddeeff0011")
|
||||
) -> BitchatMessage {
|
||||
BitchatMessage(
|
||||
id: id,
|
||||
sender: sender,
|
||||
content: content,
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: false,
|
||||
senderPeerID: senderPeerID
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Coordinator Tests Against Mock Context
|
||||
|
||||
/// Exercises `ChatPublicConversationCoordinator` against
|
||||
/// `MockChatPublicConversationContext` — no `ChatViewModel` involved.
|
||||
struct ChatPublicConversationCoordinatorContextTests {
|
||||
|
||||
@Test @MainActor
|
||||
func handlePublicMessage_meshMessage_appendsSyncsStoreAndEnqueues() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let message = makePublicMessage(id: "mesh-msg-1", content: "Hello Mesh")
|
||||
|
||||
coordinator.handlePublicMessage(message)
|
||||
|
||||
#expect(context.meshTimeline.map(\.id) == ["mesh-msg-1"])
|
||||
#expect(context.replacedChannelMessages.count == 1)
|
||||
#expect(context.replacedChannelMessages.first?.channel == .mesh)
|
||||
#expect(context.replacedChannelMessages.first?.messageIDs == ["mesh-msg-1"])
|
||||
#expect(context.rateLimitChecks.count == 1)
|
||||
#expect(context.rateLimitChecks.first?.senderKey == "mesh:aabbccddeeff0011")
|
||||
#expect(context.rateLimitChecks.first?.contentKey == "hello mesh")
|
||||
#expect(context.enqueuedMessageIDs == ["mesh-msg-1"])
|
||||
|
||||
// Already visible in the timeline: stored again, but not re-enqueued.
|
||||
context.messages = [message]
|
||||
coordinator.handlePublicMessage(message)
|
||||
#expect(context.enqueuedMessageIDs == ["mesh-msg-1"])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handlePublicMessage_blockedOrRateLimited_dropsMessage() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
|
||||
// Blocked sender: dropped before rate limiting and storage.
|
||||
context.blockedMessageIDs = ["blocked-msg"]
|
||||
coordinator.handlePublicMessage(makePublicMessage(id: "blocked-msg"))
|
||||
#expect(context.rateLimitChecks.isEmpty)
|
||||
#expect(context.meshTimeline.isEmpty)
|
||||
#expect(context.enqueuedMessageIDs.isEmpty)
|
||||
|
||||
// Rate limited: consulted, then dropped before storage.
|
||||
context.rateLimitAllowed = false
|
||||
coordinator.handlePublicMessage(makePublicMessage(id: "limited-msg"))
|
||||
#expect(context.rateLimitChecks.count == 1)
|
||||
#expect(context.meshTimeline.isEmpty)
|
||||
#expect(context.enqueuedMessageIDs.isEmpty)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handlePublicMessage_geoMessage_respectsActiveChannel() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let geohash = "u4pruy"
|
||||
context.currentGeohash = geohash
|
||||
let senderHex = String(repeating: "ab", count: 32)
|
||||
let geoMessage = makePublicMessage(
|
||||
id: "geo-msg-1",
|
||||
content: "geo hello",
|
||||
senderPeerID: PeerID(nostr: senderHex)
|
||||
)
|
||||
|
||||
// On mesh channel: stored in the geohash timeline but not enqueued.
|
||||
context.activeChannel = .mesh
|
||||
coordinator.handlePublicMessage(geoMessage)
|
||||
#expect(context.geoTimelines[geohash]?.map(\.id) == ["geo-msg-1"])
|
||||
#expect(context.replacedConversationMessages.count == 1)
|
||||
#expect(context.replacedConversationMessages.first?.conversation == .geohash(geohash))
|
||||
#expect(context.meshTimeline.isEmpty)
|
||||
#expect(context.enqueuedMessageIDs.isEmpty)
|
||||
|
||||
// On the matching location channel: enqueued for display.
|
||||
context.activeChannel = .location(GeohashChannel(level: .city, geohash: geohash))
|
||||
let second = makePublicMessage(
|
||||
id: "geo-msg-2",
|
||||
content: "geo again",
|
||||
senderPeerID: PeerID(nostr: senderHex)
|
||||
)
|
||||
coordinator.handlePublicMessage(second)
|
||||
#expect(context.enqueuedMessageIDs == ["geo-msg-2"])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func blockGeohashUser_purgesMessagesMappingsAndPrivateChats() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let geohash = "u4pruy"
|
||||
let hex = String(repeating: "cd", count: 32)
|
||||
let senderPeerID = PeerID(nostr: hex)
|
||||
let convKey = PeerID(nostr_: hex)
|
||||
let geoMessage = makePublicMessage(id: "geo-bad-1", sender: "rude", senderPeerID: senderPeerID)
|
||||
|
||||
context.currentGeohash = geohash
|
||||
context.activeChannel = .location(GeohashChannel(level: .city, geohash: geohash))
|
||||
context.geoTimelines[geohash] = [geoMessage]
|
||||
context.messages = [geoMessage]
|
||||
context.nostrKeyMapping = [senderPeerID: hex, convKey: hex]
|
||||
context.privateChats[convKey] = [geoMessage]
|
||||
context.unreadPrivateMessages = [convKey]
|
||||
|
||||
coordinator.blockGeohashUser(pubkeyHexLowercased: hex, displayName: "rude#abcd")
|
||||
|
||||
#expect(context.blockedNostrPubkeys.contains(hex))
|
||||
#expect(context.removedGeoParticipants == [hex])
|
||||
#expect(context.geoTimelines[geohash]?.isEmpty == true)
|
||||
#expect(context.privateChats[convKey] == nil)
|
||||
#expect(context.unreadPrivateMessages.isEmpty)
|
||||
#expect(context.nostrKeyMapping.isEmpty)
|
||||
// The blocked user's visible message is gone; a system notice was added.
|
||||
#expect(!context.messages.contains(where: { $0.id == "geo-bad-1" }))
|
||||
#expect(context.messages.last?.sender == "system")
|
||||
|
||||
coordinator.unblockGeohashUser(pubkeyHexLowercased: hex, displayName: "rude#abcd")
|
||||
#expect(!context.blockedNostrPubkeys.contains(hex))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func removeMessage_removesEverywhereAndCleansUpFile() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
let message = makePublicMessage(id: "doomed-msg")
|
||||
context.messages = [message]
|
||||
context.meshTimeline = [message]
|
||||
context.privateChats[peerID] = [message]
|
||||
|
||||
coordinator.removeMessage(withID: "doomed-msg", cleanupFile: true)
|
||||
|
||||
#expect(context.messages.isEmpty)
|
||||
#expect(context.meshTimeline.isEmpty)
|
||||
#expect(context.privateChats[peerID] == nil)
|
||||
#expect(context.cleanedUpFileMessageIDs == ["doomed-msg"])
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
// Timeline removal triggers a full conversation-store resync.
|
||||
#expect(context.replacedChannelMessages.contains(where: { $0.channel == .mesh && $0.messageIDs.isEmpty }))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func addPublicSystemMessage_appendsRefreshesAndRecordsContentKey() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
|
||||
coordinator.addPublicSystemMessage("Tor Ready")
|
||||
|
||||
#expect(context.meshTimeline.count == 1)
|
||||
#expect(context.meshTimeline.first?.sender == "system")
|
||||
// refreshVisibleMessages mirrors the timeline into the visible list.
|
||||
#expect(context.messages.map(\.id) == context.meshTimeline.map(\.id))
|
||||
#expect(context.recordedContentKeys.map(\.key) == ["tor ready"])
|
||||
#expect(context.trimMessagesCount == 1)
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
#expect(context.conversationActiveChannels == [.mesh])
|
||||
|
||||
// On mesh, geohash-only system messages are queued for the next geo visit.
|
||||
coordinator.addGeohashOnlySystemMessage("geo notice")
|
||||
#expect(context.queuedGeohashSystemMessages == ["geo notice"])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func sendPublicRaw_onMeshChannel_sendsViaMeshTransport() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
|
||||
coordinator.sendPublicRaw("raw mesh payload")
|
||||
|
||||
#expect(context.sentMeshMessages.count == 1)
|
||||
#expect(context.sentMeshMessages.first?.content == "raw mesh payload")
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func pipelineDelegate_readsAndWritesContextState() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let pipeline = PublicMessagePipeline()
|
||||
let message = makePublicMessage(id: "pipeline-msg")
|
||||
context.messages = [message]
|
||||
context.contentTimestamps["key-1"] = Date(timeIntervalSince1970: 42)
|
||||
|
||||
#expect(coordinator.pipelineCurrentMessages(pipeline).map(\.id) == ["pipeline-msg"])
|
||||
#expect(coordinator.pipeline(pipeline, normalizeContent: "HeLLo") == "hello")
|
||||
#expect(coordinator.pipeline(pipeline, contentTimestampForKey: "key-1") == Date(timeIntervalSince1970: 42))
|
||||
|
||||
coordinator.pipeline(pipeline, setMessages: [])
|
||||
#expect(context.messages.isEmpty)
|
||||
|
||||
coordinator.pipeline(pipeline, recordContentKey: "key-2", timestamp: Date(timeIntervalSince1970: 7))
|
||||
#expect(context.recordedContentKeys.map(\.key) == ["key-2"])
|
||||
|
||||
coordinator.pipelineTrimMessages(pipeline)
|
||||
#expect(context.trimMessagesCount == 1)
|
||||
|
||||
coordinator.pipelinePrewarmMessage(pipeline, message: message)
|
||||
#expect(context.prewarmedMessageIDs == ["pipeline-msg"])
|
||||
|
||||
coordinator.pipelineSetBatchingState(pipeline, isBatching: true)
|
||||
#expect(context.isBatchingPublic)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func currentPublicSenderAndDisplayName_deriveGeoSuffixedIdentity() async {
|
||||
let context = MockChatPublicConversationContext()
|
||||
let coordinator = ChatPublicConversationCoordinator(context: context)
|
||||
let identityHex = MockChatPublicConversationContext.dummyIdentity.publicKeyHex
|
||||
let suffix = String(identityHex.suffix(4))
|
||||
|
||||
// Mesh: plain nickname and mesh peer ID.
|
||||
let meshSender = coordinator.currentPublicSender()
|
||||
#expect(meshSender.name == "me")
|
||||
#expect(meshSender.peerID == context.myPeerID)
|
||||
|
||||
// Location channel: suffixed nickname and nostr peer ID.
|
||||
context.activeChannel = .location(GeohashChannel(level: .city, geohash: "u4pruy"))
|
||||
let geoSender = coordinator.currentPublicSender()
|
||||
#expect(geoSender.name == "me#\(suffix)")
|
||||
#expect(geoSender.peerID == PeerID(nostr: identityHex))
|
||||
|
||||
// Display names: own geo identity, known nickname, and anon fallback.
|
||||
context.currentGeohash = "u4pruy"
|
||||
#expect(coordinator.displayNameForNostrPubkey(identityHex) == "me#\(suffix)")
|
||||
let otherHex = String(repeating: "ef", count: 32)
|
||||
context.geoNicknames[otherHex] = "bob"
|
||||
#expect(coordinator.displayNameForNostrPubkey(otherHex) == "bob#" + otherHex.suffix(4))
|
||||
let unknownHex = String(repeating: "12", count: 32)
|
||||
#expect(coordinator.displayNameForNostrPubkey(unknownHex) == "anon#" + unknownHex.suffix(4))
|
||||
}
|
||||
}
|
||||
@@ -98,6 +98,30 @@ struct ChatViewModelDeliveryStatusTests {
|
||||
}())
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func deliveryStatus_identicalUpdateIsNoop() async {
|
||||
let (viewModel, transport) = makeTestableViewModel()
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
let messageID = "test-msg-identical"
|
||||
let message = BitchatMessage(
|
||||
id: messageID,
|
||||
sender: viewModel.nickname,
|
||||
content: "Test message",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer",
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
viewModel.privateChats[peerID] = [message]
|
||||
|
||||
let didUpdate = viewModel.deliveryCoordinator.updateMessageDeliveryStatus(messageID, status: .sent)
|
||||
|
||||
#expect(!didUpdate)
|
||||
#expect(isSent(viewModel.privateChats[peerID]?.first?.deliveryStatus))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func deliveryStatus_upgrade_deliveredToRead() async {
|
||||
let (viewModel, transport) = makeTestableViewModel()
|
||||
@@ -222,6 +246,104 @@ struct ChatViewModelDeliveryStatusTests {
|
||||
}())
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func deliveryStatus_updatesPublicAndMirroredPrivateMessages() async {
|
||||
let (viewModel, transport) = makeTestableViewModel()
|
||||
let messageID = "mirrored-msg-1"
|
||||
let firstPeerID = PeerID(str: "0102030405060708")
|
||||
let secondPeerID = PeerID(str: "1112131415161718")
|
||||
|
||||
viewModel.messages = [
|
||||
BitchatMessage(
|
||||
id: messageID,
|
||||
sender: viewModel.nickname,
|
||||
content: "Public copy",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: false,
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
]
|
||||
viewModel.privateChats[firstPeerID] = [
|
||||
BitchatMessage(
|
||||
id: messageID,
|
||||
sender: viewModel.nickname,
|
||||
content: "Private copy A",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer A",
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
]
|
||||
viewModel.privateChats[secondPeerID] = [
|
||||
BitchatMessage(
|
||||
id: messageID,
|
||||
sender: viewModel.nickname,
|
||||
content: "Private copy B",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer B",
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
]
|
||||
|
||||
let didUpdate = viewModel.deliveryCoordinator.updateMessageDeliveryStatus(
|
||||
messageID,
|
||||
status: .delivered(to: "Peer", at: Date())
|
||||
)
|
||||
|
||||
#expect(didUpdate)
|
||||
#expect(isDelivered(viewModel.messages.first?.deliveryStatus))
|
||||
#expect(isDelivered(viewModel.privateChats[firstPeerID]?.first?.deliveryStatus))
|
||||
#expect(isDelivered(viewModel.privateChats[secondPeerID]?.first?.deliveryStatus))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func deliveryStatus_indexRefreshesAfterPrivateChatReorder() async {
|
||||
let (viewModel, transport) = makeTestableViewModel()
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
let messageID = "reordered-msg-1"
|
||||
let olderMessage = BitchatMessage(
|
||||
id: "older-msg",
|
||||
sender: viewModel.nickname,
|
||||
content: "Older message",
|
||||
timestamp: Date(timeIntervalSince1970: 1),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer",
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
let targetMessage = BitchatMessage(
|
||||
id: messageID,
|
||||
sender: viewModel.nickname,
|
||||
content: "Target message",
|
||||
timestamp: Date(timeIntervalSince1970: 2),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer",
|
||||
senderPeerID: transport.myPeerID,
|
||||
deliveryStatus: .sent
|
||||
)
|
||||
|
||||
viewModel.privateChats[peerID] = [targetMessage, olderMessage]
|
||||
#expect(isSent(viewModel.deliveryCoordinator.deliveryStatus(for: messageID)))
|
||||
|
||||
viewModel.privateChats[peerID] = [olderMessage, targetMessage]
|
||||
let didUpdate = viewModel.deliveryCoordinator.updateMessageDeliveryStatus(
|
||||
messageID,
|
||||
status: .read(by: "Peer", at: Date())
|
||||
)
|
||||
|
||||
#expect(didUpdate)
|
||||
#expect(isRead(viewModel.privateChats[peerID]?.last?.deliveryStatus))
|
||||
}
|
||||
|
||||
// MARK: - Status Rank Tests (for deduplication)
|
||||
|
||||
@Test @MainActor
|
||||
@@ -252,3 +374,145 @@ struct ChatViewModelDeliveryStatusTests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Mock Delivery Context
|
||||
|
||||
/// Lightweight stand-in for `ChatDeliveryContext` proving that
|
||||
/// `ChatDeliveryCoordinator` is testable without constructing a `ChatViewModel`.
|
||||
@MainActor
|
||||
private final class MockChatDeliveryContext: ChatDeliveryContext {
|
||||
var messages: [BitchatMessage] = []
|
||||
var privateChats: [PeerID: [BitchatMessage]] = [:]
|
||||
var sentReadReceipts: Set<String> = []
|
||||
var isStartupPhase = false
|
||||
private(set) var notifyUIChangedCount = 0
|
||||
private(set) var markedDeliveredMessageIDs: [String] = []
|
||||
|
||||
func notifyUIChanged() {
|
||||
notifyUIChangedCount += 1
|
||||
}
|
||||
|
||||
func markMessageDelivered(_ messageID: String) {
|
||||
markedDeliveredMessageIDs.append(messageID)
|
||||
}
|
||||
}
|
||||
|
||||
@MainActor
|
||||
private func makePrivateMessage(id: String, status: DeliveryStatus) -> BitchatMessage {
|
||||
BitchatMessage(
|
||||
id: id,
|
||||
sender: "me",
|
||||
content: "Test message",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: true,
|
||||
recipientNickname: "Peer",
|
||||
senderPeerID: PeerID(str: "aabbccddeeff0011"),
|
||||
deliveryStatus: status
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - Coordinator Tests Against Mock Context
|
||||
|
||||
/// Exercises `ChatDeliveryCoordinator` against `MockChatDeliveryContext` —
|
||||
/// the exemplar for the narrow-dependency coordinator pattern.
|
||||
struct ChatDeliveryCoordinatorContextTests {
|
||||
|
||||
@Test @MainActor
|
||||
func updateDeliveryStatus_updatesPrivateChatNotifiesAndMarksDelivered() async {
|
||||
let context = MockChatDeliveryContext()
|
||||
let coordinator = ChatDeliveryCoordinator(context: context)
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
let messageID = "mock-msg-1"
|
||||
context.privateChats[peerID] = [makePrivateMessage(id: messageID, status: .sent)]
|
||||
|
||||
let didUpdate = coordinator.updateMessageDeliveryStatus(
|
||||
messageID,
|
||||
status: .delivered(to: "Peer", at: Date())
|
||||
)
|
||||
|
||||
#expect(didUpdate)
|
||||
#expect(isDelivered(context.privateChats[peerID]?.first?.deliveryStatus))
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
#expect(context.markedDeliveredMessageIDs == [messageID])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func readReceipt_marksDeliveredAndUpgradesStatus() async {
|
||||
let context = MockChatDeliveryContext()
|
||||
let coordinator = ChatDeliveryCoordinator(context: context)
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
let messageID = "mock-msg-2"
|
||||
context.privateChats[peerID] = [makePrivateMessage(id: messageID, status: .delivered(to: "Peer", at: Date()))]
|
||||
|
||||
coordinator.didReceiveReadReceipt(
|
||||
ReadReceipt(originalMessageID: messageID, readerID: peerID, readerNickname: "Peer")
|
||||
)
|
||||
|
||||
#expect(isRead(context.privateChats[peerID]?.first?.deliveryStatus))
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
#expect(context.markedDeliveredMessageIDs == [messageID])
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func sentStatus_doesNotMarkDeliveredAndUnknownMessageDoesNotNotify() async {
|
||||
let context = MockChatDeliveryContext()
|
||||
let coordinator = ChatDeliveryCoordinator(context: context)
|
||||
context.messages = [
|
||||
BitchatMessage(
|
||||
id: "public-mock-1",
|
||||
sender: "me",
|
||||
content: "Public message",
|
||||
timestamp: Date(),
|
||||
isRelay: false,
|
||||
isPrivate: false,
|
||||
deliveryStatus: .sending
|
||||
)
|
||||
]
|
||||
|
||||
// .sent is not a confirmed receipt — must not reach markMessageDelivered.
|
||||
let didUpdate = coordinator.updateMessageDeliveryStatus("public-mock-1", status: .sent)
|
||||
#expect(didUpdate)
|
||||
#expect(isSent(context.messages.first?.deliveryStatus))
|
||||
#expect(context.markedDeliveredMessageIDs.isEmpty)
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
|
||||
// Unknown message: no state change, no extra UI notification.
|
||||
let didUpdateUnknown = coordinator.updateMessageDeliveryStatus("missing-msg", status: .sent)
|
||||
#expect(!didUpdateUnknown)
|
||||
#expect(context.notifyUIChangedCount == 1)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func cleanupOldReadReceipts_prunesReceiptsAgainstMockContext() async {
|
||||
let context = MockChatDeliveryContext()
|
||||
let coordinator = ChatDeliveryCoordinator(context: context)
|
||||
let peerID = PeerID(str: "0102030405060708")
|
||||
context.privateChats[peerID] = [makePrivateMessage(id: "keep-receipt", status: .sent)]
|
||||
context.sentReadReceipts = ["keep-receipt", "drop-receipt"]
|
||||
|
||||
// Startup phase: cleanup must be a no-op.
|
||||
context.isStartupPhase = true
|
||||
coordinator.cleanupOldReadReceipts()
|
||||
#expect(context.sentReadReceipts == ["keep-receipt", "drop-receipt"])
|
||||
|
||||
context.isStartupPhase = false
|
||||
coordinator.cleanupOldReadReceipts()
|
||||
#expect(context.sentReadReceipts == ["keep-receipt"])
|
||||
}
|
||||
}
|
||||
|
||||
private func isSent(_ status: DeliveryStatus?) -> Bool {
|
||||
if case .sent = status { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
private func isDelivered(_ status: DeliveryStatus?) -> Bool {
|
||||
if case .delivered = status { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
private func isRead(_ status: DeliveryStatus?) -> Bool {
|
||||
if case .read = status { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -398,6 +398,26 @@ struct ChatViewModelNostrExtensionTests {
|
||||
#expect(viewModel.privateChats.isEmpty)
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func handleNostrMessage_invalidSignatureDoesNotPoisonDedup() async throws {
|
||||
let (viewModel, _) = makeTestableViewModel()
|
||||
let sender = try NostrIdentity.generate()
|
||||
let recipient = try #require(try viewModel.idBridge.getCurrentNostrIdentity())
|
||||
let giftWrap = try NostrProtocol.createPrivateMessage(
|
||||
content: "verify:noop",
|
||||
recipientPubkey: recipient.publicKeyHex,
|
||||
senderIdentity: sender
|
||||
)
|
||||
var invalidGiftWrap = giftWrap
|
||||
invalidGiftWrap.sig = String(repeating: "0", count: 128)
|
||||
|
||||
viewModel.handleNostrMessage(invalidGiftWrap)
|
||||
#expect(!viewModel.deduplicationService.hasProcessedNostrEvent(giftWrap.id))
|
||||
|
||||
viewModel.handleNostrMessage(giftWrap)
|
||||
#expect(viewModel.deduplicationService.hasProcessedNostrEvent(giftWrap.id))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func switchLocationChannel_clearsNostrDedupCache() async {
|
||||
let (viewModel, _) = makeTestableViewModel()
|
||||
|
||||
@@ -278,6 +278,75 @@ struct ChatViewModelPresenceHandlingTests {
|
||||
#expect(count >= 1)
|
||||
}
|
||||
|
||||
@Test func subscribeNostrEvent_samplingDeduplicatesSameEventAcrossGeohashes() async throws {
|
||||
let (viewModel, _) = makeTestableViewModel()
|
||||
let firstGeohash = "u4pru"
|
||||
let secondGeohash = "u4pruy"
|
||||
let identity = try NostrIdentity.generate()
|
||||
let event = NostrEvent(
|
||||
pubkey: identity.publicKeyHex,
|
||||
createdAt: Date(),
|
||||
kind: .geohashPresence,
|
||||
tags: [["g", secondGeohash]],
|
||||
content: ""
|
||||
)
|
||||
let signed = try event.sign(with: identity.schnorrSigningKey())
|
||||
|
||||
viewModel.subscribeNostrEvent(signed, gh: firstGeohash)
|
||||
viewModel.subscribeNostrEvent(signed, gh: secondGeohash)
|
||||
|
||||
#expect(viewModel.geohashParticipantCount(for: firstGeohash) == 1)
|
||||
#expect(viewModel.geohashParticipantCount(for: secondGeohash) == 0)
|
||||
}
|
||||
|
||||
@Test func subscribeNostrEvent_samplingDedupDoesNotBlockActiveChannelProcessing() async throws {
|
||||
let (viewModel, _) = makeTestableViewModel()
|
||||
let sampleGeohash = "u4pru"
|
||||
let activeGeohash = "u4pruy"
|
||||
let identity = try NostrIdentity.generate()
|
||||
|
||||
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: activeGeohash)))
|
||||
|
||||
let event = NostrEvent(
|
||||
pubkey: identity.publicKeyHex,
|
||||
createdAt: Date(),
|
||||
kind: .geohashPresence,
|
||||
tags: [["g", sampleGeohash]],
|
||||
content: ""
|
||||
)
|
||||
let signed = try event.sign(with: identity.schnorrSigningKey())
|
||||
|
||||
viewModel.subscribeNostrEvent(signed, gh: sampleGeohash)
|
||||
#expect(!viewModel.deduplicationService.hasProcessedNostrEvent(signed.id))
|
||||
|
||||
viewModel.subscribeNostrEvent(signed)
|
||||
|
||||
#expect(viewModel.geohashParticipantCount(for: sampleGeohash) == 1)
|
||||
#expect(viewModel.deduplicationService.hasProcessedNostrEvent(signed.id))
|
||||
#expect(viewModel.geohashParticipantCount(for: activeGeohash) >= 1)
|
||||
}
|
||||
|
||||
@Test func subscribeNostrEvent_samplingInvalidSignatureDoesNotPoisonDedup() async throws {
|
||||
let (viewModel, _) = makeTestableViewModel()
|
||||
let sampleGeohash = "u4pru"
|
||||
let identity = try NostrIdentity.generate()
|
||||
let event = NostrEvent(
|
||||
pubkey: identity.publicKeyHex,
|
||||
createdAt: Date(),
|
||||
kind: .geohashPresence,
|
||||
tags: [["g", sampleGeohash]],
|
||||
content: ""
|
||||
)
|
||||
let signed = try event.sign(with: identity.schnorrSigningKey())
|
||||
var invalid = signed
|
||||
invalid.sig = String(repeating: "0", count: 128)
|
||||
|
||||
viewModel.subscribeNostrEvent(invalid, gh: sampleGeohash)
|
||||
viewModel.subscribeNostrEvent(signed, gh: sampleGeohash)
|
||||
|
||||
#expect(viewModel.geohashParticipantCount(for: sampleGeohash) == 1)
|
||||
}
|
||||
|
||||
// MARK: - Test Helper
|
||||
|
||||
private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
|
||||
|
||||
@@ -0,0 +1,220 @@
|
||||
//
|
||||
// LargeTopologyTests.swift
|
||||
// bitchatTests
|
||||
//
|
||||
// This is free and unencumbered software released into the public domain.
|
||||
// For more information, see <https://unlicense.org>
|
||||
//
|
||||
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import BitFoundation // to avoid unnecessary public's
|
||||
@testable import bitchat
|
||||
|
||||
/// Production-shaped topology tests: deep relay chains, larger partial meshes,
|
||||
/// partitions, and churn.
|
||||
///
|
||||
/// Determinism: `MockBLEService` flooding is fully synchronous — `sendMessage`
|
||||
/// recurses through `simulateIncomingPacket` across the whole connected
|
||||
/// component before returning — so every test here sends, then asserts, with
|
||||
/// no waits, sleeps, or confirmations needed.
|
||||
struct LargeTopologyTests {
|
||||
|
||||
private let helper = TestNetworkHelper()
|
||||
|
||||
/// content -> receiver name -> delivery count.
|
||||
/// Delivery in the mock harness is single-threaded and synchronous, so
|
||||
/// plain (unlocked) mutation is safe here.
|
||||
private final class DeliveryLog {
|
||||
private(set) var counts: [String: [String: Int]] = [:]
|
||||
func record(receiver: String, content: String) {
|
||||
counts[content, default: [:]][receiver, default: 0] += 1
|
||||
}
|
||||
func deliveries(of content: String) -> [String: Int] {
|
||||
counts[content] ?? [:]
|
||||
}
|
||||
}
|
||||
|
||||
private func makeNodes(_ names: [String]) {
|
||||
for name in names {
|
||||
helper.createNode(name, peerID: PeerID(str: UUID().uuidString))
|
||||
}
|
||||
}
|
||||
|
||||
/// Installs a counting message handler on every node. Local echo does not
|
||||
/// trigger `messageDeliveryHandler`, so the sender of a broadcast records
|
||||
/// no delivery for its own message.
|
||||
private func installDeliveryLog() -> DeliveryLog {
|
||||
let log = DeliveryLog()
|
||||
for (name, node) in helper.nodes {
|
||||
node.messageDeliveryHandler = { message in
|
||||
log.record(receiver: name, content: message.content)
|
||||
}
|
||||
}
|
||||
return log
|
||||
}
|
||||
|
||||
// MARK: - Deep chain
|
||||
|
||||
@Test func deepChainBroadcastTraversesAllHopsWithTTLDecay() {
|
||||
// A - B - C - D - E - F - G - H (7 hops end to end)
|
||||
let chain = ["A", "B", "C", "D", "E", "F", "G", "H"]
|
||||
makeNodes(chain)
|
||||
for i in 0..<(chain.count - 1) {
|
||||
helper.connect(chain[i], chain[i + 1])
|
||||
}
|
||||
|
||||
let log = installDeliveryLog()
|
||||
|
||||
// Record the highest TTL each node observes for the broadcast. The
|
||||
// shortest-path arrival carries the highest TTL (back-floods from
|
||||
// further down the chain have decayed further), and unlike
|
||||
// "first handler call" this is independent of recursion order — the
|
||||
// mock invokes packetDeliveryHandler after its recursive flood, so
|
||||
// innermost calls fire first.
|
||||
var maxSeenTTL: [String: UInt8] = [:]
|
||||
for name in chain.dropFirst() {
|
||||
helper.nodes[name]!.packetDeliveryHandler = { packet in
|
||||
if let message = BitchatMessage(packet.payload),
|
||||
message.content == "deep chain probe" {
|
||||
maxSeenTTL[name] = max(maxSeenTTL[name] ?? 0, packet.ttl)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
helper.nodes["A"]!.sendMessage("deep chain probe")
|
||||
|
||||
// Reachability: the broadcast relays across all 7 hops and lands
|
||||
// exactly once at every other node (seenMessageIDs dedup).
|
||||
let deliveries = log.deliveries(of: "deep chain probe")
|
||||
for name in chain.dropFirst() {
|
||||
#expect(deliveries[name] == 1, "\(name) should receive the broadcast exactly once")
|
||||
}
|
||||
#expect(deliveries["A"] == nil, "sender must not receive its own broadcast")
|
||||
|
||||
// TTL-modeling gap: the mock decrements and clamps TTL while flooding,
|
||||
// but it intentionally does NOT stop relaying when TTL reaches 0 —
|
||||
// MockBLEService floods the entire connected component and relies on
|
||||
// seenMessageIDs dedup (see the comment in simulateIncomingPacket).
|
||||
// Production BLEService enforces TTL and drops packets at 0 (max 7
|
||||
// hops), so this 7-hop chain only succeeds end to end because the mock
|
||||
// does not enforce TTL. We therefore assert decay and clamping here,
|
||||
// not enforcement.
|
||||
let initialTTL = helper.nodes["A"]!.sentPackets.last!.ttl
|
||||
var previousTTL = initialTTL
|
||||
for (hop, name) in chain.dropFirst().enumerated() {
|
||||
// The first hop carries the original TTL (sendMessage delivers the
|
||||
// packet unmodified); each subsequent relay decrements, clamped at 0.
|
||||
let expected = initialTTL > UInt8(hop) ? initialTTL - UInt8(hop) : 0
|
||||
let observed = maxSeenTTL[name]
|
||||
#expect(observed == expected, "\(name) expected shortest-path TTL \(expected), got \(String(describing: observed))")
|
||||
if let observed {
|
||||
#expect(observed <= initialTTL, "TTL must never exceed the initial TTL")
|
||||
#expect(observed <= previousTTL, "TTL must be non-increasing along the chain")
|
||||
previousTTL = observed
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Larger partial mesh
|
||||
|
||||
@Test func partialMeshBroadcastReachesAllExactlyOnce() {
|
||||
// 14 peers in a ring with chord edges: redundant paths create cycles,
|
||||
// so duplicate suppression (seenMessageIDs) is genuinely exercised.
|
||||
let names = (0..<14).map { String(format: "M%02d", $0) }
|
||||
makeNodes(names)
|
||||
for i in 0..<names.count {
|
||||
helper.connect(names[i], names[(i + 1) % names.count])
|
||||
}
|
||||
for i in [0, 3, 6, 9] {
|
||||
helper.connect(names[i], names[(i + 5) % names.count])
|
||||
}
|
||||
|
||||
let log = installDeliveryLog()
|
||||
helper.nodes[names[0]]!.sendMessage("mesh broadcast")
|
||||
|
||||
let deliveries = log.deliveries(of: "mesh broadcast")
|
||||
for name in names.dropFirst() {
|
||||
#expect(deliveries[name] == 1, "\(name) should receive exactly once despite redundant paths, got \(String(describing: deliveries[name]))")
|
||||
}
|
||||
#expect(deliveries[names[0]] == nil, "sender must not receive its own broadcast")
|
||||
}
|
||||
|
||||
// MARK: - Partition and heal
|
||||
|
||||
@Test func partitionIsolatesComponentsAndBridgeHeals() {
|
||||
// Two 5-node components, each with a redundant internal edge.
|
||||
let names = (0..<10).map { "P\($0)" }
|
||||
makeNodes(names)
|
||||
for i in 0..<4 { helper.connect("P\(i)", "P\(i + 1)") }
|
||||
helper.connect("P0", "P2")
|
||||
for i in 5..<9 { helper.connect("P\(i)", "P\(i + 1)") }
|
||||
helper.connect("P7", "P9")
|
||||
|
||||
let log = installDeliveryLog()
|
||||
|
||||
// While partitioned, nothing crosses.
|
||||
helper.nodes["P0"]!.sendMessage("pre-heal")
|
||||
var deliveries = log.deliveries(of: "pre-heal")
|
||||
for i in 1...4 { #expect(deliveries["P\(i)"] == 1, "P\(i) is in the sender's component") }
|
||||
for i in 5...9 { #expect(deliveries["P\(i)"] == nil, "P\(i) must not receive across the partition") }
|
||||
|
||||
// Heal with a single bridge edge; newly sent messages flow across.
|
||||
helper.connect("P4", "P5")
|
||||
helper.nodes["P0"]!.sendMessage("post-heal")
|
||||
deliveries = log.deliveries(of: "post-heal")
|
||||
for i in 1...9 { #expect(deliveries["P\(i)"] == 1, "P\(i) should receive after the bridge heals the partition") }
|
||||
|
||||
// The harness has no store-and-forward: the pre-partition message is
|
||||
// not retroactively delivered once the bridge appears.
|
||||
let preHeal = log.deliveries(of: "pre-heal")
|
||||
for i in 5...9 { #expect(preHeal["P\(i)"] == nil, "no store-and-forward of pre-partition messages") }
|
||||
}
|
||||
|
||||
// MARK: - Churn
|
||||
|
||||
@Test func churnDeliversToCurrentlyConnectedComponentOnly() {
|
||||
// 10-peer ring, then repeatedly mutate the topology between broadcasts.
|
||||
let names = (0..<10).map { "C\($0)" }
|
||||
makeNodes(names)
|
||||
for i in 0..<10 { helper.connect("C\(i)", "C\((i + 1) % 10)") }
|
||||
|
||||
let log = installDeliveryLog()
|
||||
|
||||
// Round 1: cut the ring in two places ->
|
||||
// components {C8, C9, C0, C1, C2} and {C3, C4, C5, C6, C7}.
|
||||
helper.disconnect("C2", "C3")
|
||||
helper.disconnect("C7", "C8")
|
||||
helper.nodes["C0"]!.sendMessage("split round")
|
||||
var deliveries = log.deliveries(of: "split round")
|
||||
for name in ["C1", "C2", "C8", "C9"] {
|
||||
#expect(deliveries[name] == 1, "\(name) is in C0's component and should receive exactly once")
|
||||
}
|
||||
for i in 3...7 { #expect(deliveries["C\(i)"] == nil, "C\(i) is in the other component") }
|
||||
|
||||
// Round 2: restore the ring; a broadcast from the far side reaches all.
|
||||
helper.connect("C2", "C3")
|
||||
helper.connect("C7", "C8")
|
||||
helper.nodes["C5"]!.sendMessage("healed round")
|
||||
deliveries = log.deliveries(of: "healed round")
|
||||
for name in names where name != "C5" {
|
||||
#expect(deliveries[name] == 1, "\(name) should receive exactly once after the ring heals")
|
||||
}
|
||||
#expect(deliveries["C5"] == nil, "sender must not receive its own broadcast")
|
||||
|
||||
// Round 3: fully isolate C9; everyone else still receives.
|
||||
helper.disconnect("C8", "C9")
|
||||
helper.disconnect("C9", "C0")
|
||||
helper.nodes["C0"]!.sendMessage("isolated round")
|
||||
deliveries = log.deliveries(of: "isolated round")
|
||||
for i in 1...8 { #expect(deliveries["C\(i)"] == 1, "C\(i) remains connected and should receive") }
|
||||
#expect(deliveries["C9"] == nil, "isolated node must not receive")
|
||||
|
||||
// Round 4: rejoin C9; a broadcast from the rejoined node reaches all.
|
||||
helper.connect("C9", "C0")
|
||||
helper.nodes["C9"]!.sendMessage("rejoined round")
|
||||
deliveries = log.deliveries(of: "rejoined round")
|
||||
for i in 0...8 { #expect(deliveries["C\(i)"] == 1, "C\(i) should receive from the rejoined node") }
|
||||
#expect(deliveries["C9"] == nil, "sender must not receive its own broadcast")
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import BitFoundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
@@ -21,6 +22,38 @@ struct PublicTimelineStoreTests {
|
||||
#expect(messages.map(\.content) == ["two", "three"])
|
||||
}
|
||||
|
||||
@Test("Timeline indexes allow trimmed message IDs to return")
|
||||
func timelineIndexesAllowTrimmedMessageIDsToReturn() {
|
||||
var store = PublicTimelineStore(meshCap: 2, geohashCap: 2)
|
||||
let first = timelineMessage(id: "one", content: "one", timestamp: 1)
|
||||
let second = timelineMessage(id: "two", content: "two", timestamp: 2)
|
||||
let third = timelineMessage(id: "three", content: "three", timestamp: 3)
|
||||
|
||||
store.append(first, to: .mesh)
|
||||
store.append(second, to: .mesh)
|
||||
store.append(third, to: .mesh)
|
||||
store.append(first, to: .mesh)
|
||||
|
||||
#expect(store.messages(for: .mesh).map(\.content) == ["three", "one"])
|
||||
|
||||
let geohash = "u4pruydq"
|
||||
let channel = ChannelID.location(GeohashChannel(level: .city, geohash: geohash))
|
||||
let geoFirst = timelineMessage(id: "geo-one", content: "geo one", timestamp: 1)
|
||||
let geoSecond = timelineMessage(id: "geo-two", content: "geo two", timestamp: 2)
|
||||
let geoThird = timelineMessage(id: "geo-three", content: "geo three", timestamp: 3)
|
||||
|
||||
let didAppendGeoFirst = store.appendIfAbsent(geoFirst, toGeohash: geohash)
|
||||
let didAppendGeoSecond = store.appendIfAbsent(geoSecond, toGeohash: geohash)
|
||||
let didAppendGeoThird = store.appendIfAbsent(geoThird, toGeohash: geohash)
|
||||
let didReappendGeoFirst = store.appendIfAbsent(geoFirst, toGeohash: geohash)
|
||||
|
||||
#expect(didAppendGeoFirst)
|
||||
#expect(didAppendGeoSecond)
|
||||
#expect(didAppendGeoThird)
|
||||
#expect(didReappendGeoFirst)
|
||||
#expect(store.messages(for: channel).map(\.content) == ["geo one", "geo three"])
|
||||
}
|
||||
|
||||
@Test("Geohash appendIfAbsent remove and clear work together")
|
||||
func geohashStoreSupportsAppendRemoveAndClear() {
|
||||
var store = PublicTimelineStore(meshCap: 2, geohashCap: 3)
|
||||
@@ -69,4 +102,14 @@ struct PublicTimelineStoreTests {
|
||||
#expect(store.drainPendingGeohashSystemMessages() == ["first", "second"])
|
||||
#expect(store.drainPendingGeohashSystemMessages().isEmpty)
|
||||
}
|
||||
|
||||
private func timelineMessage(id: String, content: String, timestamp: TimeInterval) -> BitchatMessage {
|
||||
BitchatMessage(
|
||||
id: id,
|
||||
sender: "alice",
|
||||
content: content,
|
||||
timestamp: Date(timeIntervalSince1970: timestamp),
|
||||
isRelay: false
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,433 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
struct BLEAnnounceHandlerTests {
|
||||
private final class Recorder {
|
||||
var existingNoisePublicKey: Data?
|
||||
var signatureValid = true
|
||||
var linkState: (hasPeripheral: Bool, hasCentral: Bool) = (false, false)
|
||||
var upsertResult = BLEPeerAnnounceUpdate(isNewPeer: false, wasDisconnected: false, previousNickname: nil)
|
||||
var dedupSeenIDs: Set<String> = []
|
||||
var shouldEmitReconnectLogResult = true
|
||||
|
||||
var verifySignatureCalls: [(packet: BitchatPacket, signingPublicKey: Data)] = []
|
||||
var barrierCount = 0
|
||||
var upsertCalls: [(peerID: PeerID, announcement: AnnouncementPacket, isConnected: Bool, now: Date)] = []
|
||||
var reconnectLogQueries: [PeerID] = []
|
||||
var topologyUpdates: [(peerID: PeerID, neighbors: [Data])] = []
|
||||
var persistedIdentities: [AnnouncementPacket] = []
|
||||
var dedupContainsQueries: [String] = []
|
||||
var dedupMarkedIDs: [String] = []
|
||||
var uiEventDeliveries: [(peerID: PeerID, notifyPeerConnected: Bool, scheduleInitialSync: Bool)] = []
|
||||
var trackedPackets: [BitchatPacket] = []
|
||||
var announceBacks = 0
|
||||
var afterglowDelays: [TimeInterval] = []
|
||||
}
|
||||
|
||||
private func makeHandler(
|
||||
recorder: Recorder,
|
||||
localPeerID: PeerID = PeerID(str: "0102030405060708"),
|
||||
now: Date = Date(timeIntervalSince1970: 1_000)
|
||||
) -> BLEAnnounceHandler {
|
||||
let environment = BLEAnnounceHandlerEnvironment(
|
||||
localPeerID: { localPeerID },
|
||||
messageTTL: TransportConfig.messageTTLDefault,
|
||||
now: { now },
|
||||
existingNoisePublicKey: { _ in recorder.existingNoisePublicKey },
|
||||
verifySignature: { packet, signingPublicKey in
|
||||
recorder.verifySignatureCalls.append((packet, signingPublicKey))
|
||||
return recorder.signatureValid
|
||||
},
|
||||
linkState: { _ in recorder.linkState },
|
||||
withRegistryBarrier: { body in
|
||||
recorder.barrierCount += 1
|
||||
body()
|
||||
},
|
||||
upsertVerifiedAnnounce: { peerID, announcement, isConnected, now in
|
||||
recorder.upsertCalls.append((peerID, announcement, isConnected, now))
|
||||
return recorder.upsertResult
|
||||
},
|
||||
shouldEmitReconnectLog: { peerID, _ in
|
||||
recorder.reconnectLogQueries.append(peerID)
|
||||
return recorder.shouldEmitReconnectLogResult
|
||||
},
|
||||
updateTopology: { peerID, neighbors in
|
||||
recorder.topologyUpdates.append((peerID, neighbors))
|
||||
},
|
||||
persistIdentity: { announcement in
|
||||
recorder.persistedIdentities.append(announcement)
|
||||
},
|
||||
dedupContains: { id in
|
||||
recorder.dedupContainsQueries.append(id)
|
||||
return recorder.dedupSeenIDs.contains(id)
|
||||
},
|
||||
dedupMarkProcessed: { id in
|
||||
recorder.dedupMarkedIDs.append(id)
|
||||
},
|
||||
deliverAnnounceUIEvents: { peerID, notifyPeerConnected, scheduleInitialSync in
|
||||
recorder.uiEventDeliveries.append((peerID, notifyPeerConnected, scheduleInitialSync))
|
||||
},
|
||||
trackPacketSeen: { packet in
|
||||
recorder.trackedPackets.append(packet)
|
||||
},
|
||||
sendAnnounceBack: {
|
||||
recorder.announceBacks += 1
|
||||
},
|
||||
scheduleAfterglow: { delay in
|
||||
recorder.afterglowDelays.append(delay)
|
||||
}
|
||||
)
|
||||
return BLEAnnounceHandler(environment: environment)
|
||||
}
|
||||
|
||||
@Test
|
||||
func verifiedNewPeerAnnounceUpsertsNotifiesSyncsAndAnnouncesBack() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x11, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.upsertResult = BLEPeerAnnounceUpdate(isNewPeer: true, wasDisconnected: false, previousNickname: nil)
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.verifySignatureCalls.count == 1)
|
||||
#expect(recorder.verifySignatureCalls.first?.signingPublicKey == Data(repeating: 0x99, count: 32))
|
||||
#expect(recorder.barrierCount == 1)
|
||||
#expect(recorder.upsertCalls.count == 1)
|
||||
#expect(recorder.upsertCalls.first?.peerID == peerID)
|
||||
#expect(recorder.upsertCalls.first?.announcement.nickname == "Alice")
|
||||
#expect(recorder.upsertCalls.first?.isConnected == true)
|
||||
#expect(recorder.upsertCalls.first?.now == now)
|
||||
#expect(recorder.persistedIdentities.count == 1)
|
||||
#expect(recorder.persistedIdentities.first?.noisePublicKey == noiseKey)
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.peerID == peerID)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == true)
|
||||
#expect(recorder.uiEventDeliveries.first?.scheduleInitialSync == true)
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.dedupMarkedIDs == ["announce-back-\(peerID)"])
|
||||
#expect(recorder.announceBacks == 1)
|
||||
#expect(recorder.afterglowDelays.count == 1)
|
||||
}
|
||||
|
||||
@Test
|
||||
func afterglowDelayStaysWithinConfiguredRange() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x12, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.upsertResult = BLEPeerAnnounceUpdate(isNewPeer: true, wasDisconnected: false, previousNickname: nil)
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
for _ in 0..<8 {
|
||||
handler.handle(packet, from: peerID)
|
||||
}
|
||||
|
||||
#expect(recorder.afterglowDelays.count == 8)
|
||||
for delay in recorder.afterglowDelays {
|
||||
#expect(delay >= 0.3 && delay <= 0.6)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
func unverifiedAnnounceWithoutSignatureSkipsUpsertAndConnectNotify() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x22, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: nil
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.verifySignatureCalls.isEmpty)
|
||||
#expect(recorder.barrierCount == 1)
|
||||
#expect(recorder.upsertCalls.isEmpty)
|
||||
#expect(recorder.topologyUpdates.isEmpty)
|
||||
#expect(recorder.afterglowDelays.isEmpty)
|
||||
// Original behavior: list refresh, identity persistence, sync tracking
|
||||
// and announce-back still occur for unverified announces.
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == false)
|
||||
#expect(recorder.uiEventDeliveries.first?.scheduleInitialSync == false)
|
||||
#expect(recorder.persistedIdentities.count == 1)
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.announceBacks == 1)
|
||||
}
|
||||
|
||||
@Test
|
||||
func invalidSignatureSkipsUpsertAndConnectNotify() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x23, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.signatureValid = false
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.verifySignatureCalls.count == 1)
|
||||
#expect(recorder.upsertCalls.isEmpty)
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == false)
|
||||
}
|
||||
|
||||
@Test
|
||||
func malformedAnnounceIsNoOp() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let peerID = PeerID(str: "1122334455667788")
|
||||
let packet = BitchatPacket(
|
||||
type: MessageType.announce.rawValue,
|
||||
senderID: Data(hexString: peerID.id) ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: timestamp(now),
|
||||
payload: Data([0x01, 0x20]),
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func selfAnnounceIsNoOp() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x33, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, localPeerID: peerID, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func staleAnnounceIsNoOp() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x44, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let staleTimestamp = UInt64((now.timeIntervalSince1970 - 901) * 1000)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: staleTimestamp,
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func reconnectedPeerNotifiesConnectionWithoutAfterglow() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x55, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.upsertResult = BLEPeerAnnounceUpdate(isNewPeer: false, wasDisconnected: true, previousNickname: "Alice")
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.peerID == peerID)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == true)
|
||||
#expect(recorder.uiEventDeliveries.first?.scheduleInitialSync == true)
|
||||
#expect(recorder.reconnectLogQueries == [peerID])
|
||||
#expect(recorder.afterglowDelays.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func relayedNewPeerSchedulesAfterglowWithoutConnectNotify() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x66, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64),
|
||||
ttl: TransportConfig.messageTTLDefault - 1
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.upsertResult = BLEPeerAnnounceUpdate(isNewPeer: true, wasDisconnected: false, previousNickname: nil)
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.upsertCalls.count == 1)
|
||||
#expect(recorder.upsertCalls.first?.isConnected == false)
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == false)
|
||||
#expect(recorder.uiEventDeliveries.first?.scheduleInitialSync == false)
|
||||
#expect(recorder.afterglowDelays.count == 1)
|
||||
}
|
||||
|
||||
@Test
|
||||
func announceBackIsSkippedWhenAlreadyMarked() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x77, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.dedupSeenIDs = ["announce-back-\(peerID)"]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.dedupContainsQueries == ["announce-back-\(peerID)"])
|
||||
#expect(recorder.dedupMarkedIDs.isEmpty)
|
||||
#expect(recorder.announceBacks == 0)
|
||||
}
|
||||
|
||||
@Test
|
||||
func verifiedAnnounceWithNeighborsUpdatesTopology() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x88, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let neighbors = [Data(repeating: 0xAB, count: 8), Data(repeating: 0xCD, count: 8)]
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64),
|
||||
directNeighbors: neighbors
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.topologyUpdates.count == 1)
|
||||
#expect(recorder.topologyUpdates.first?.peerID == peerID)
|
||||
#expect(recorder.topologyUpdates.first?.neighbors == neighbors)
|
||||
}
|
||||
|
||||
@Test
|
||||
func keyMismatchWithExistingPeerKeepsAnnounceUnverified() throws {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let noiseKey = Data(repeating: 0x99, count: 32)
|
||||
let peerID = PeerID(publicKey: noiseKey)
|
||||
let packet = try makeAnnouncePacket(
|
||||
noisePublicKey: noiseKey,
|
||||
peerID: peerID,
|
||||
timestamp: timestamp(now),
|
||||
signature: Data(repeating: 0xEE, count: 64)
|
||||
)
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.existingNoisePublicKey = Data(repeating: 0xAA, count: 32)
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
|
||||
handler.handle(packet, from: peerID)
|
||||
|
||||
#expect(recorder.upsertCalls.isEmpty)
|
||||
#expect(recorder.uiEventDeliveries.count == 1)
|
||||
#expect(recorder.uiEventDeliveries.first?.notifyPeerConnected == false)
|
||||
}
|
||||
|
||||
private func expectNoSideEffects(_ recorder: Recorder) {
|
||||
#expect(recorder.barrierCount == 0)
|
||||
#expect(recorder.upsertCalls.isEmpty)
|
||||
#expect(recorder.topologyUpdates.isEmpty)
|
||||
#expect(recorder.persistedIdentities.isEmpty)
|
||||
#expect(recorder.dedupMarkedIDs.isEmpty)
|
||||
#expect(recorder.uiEventDeliveries.isEmpty)
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.announceBacks == 0)
|
||||
#expect(recorder.afterglowDelays.isEmpty)
|
||||
}
|
||||
|
||||
private func makeAnnouncePacket(
|
||||
noisePublicKey: Data,
|
||||
peerID: PeerID,
|
||||
timestamp: UInt64,
|
||||
signature: Data?,
|
||||
ttl: UInt8 = TransportConfig.messageTTLDefault,
|
||||
directNeighbors: [Data]? = nil
|
||||
) throws -> BitchatPacket {
|
||||
let announcement = AnnouncementPacket(
|
||||
nickname: "Alice",
|
||||
noisePublicKey: noisePublicKey,
|
||||
signingPublicKey: Data(repeating: 0x99, count: 32),
|
||||
directNeighbors: directNeighbors
|
||||
)
|
||||
let payload = try #require(announcement.encode())
|
||||
|
||||
return BitchatPacket(
|
||||
type: MessageType.announce.rawValue,
|
||||
senderID: Data(hexString: peerID.id) ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: timestamp,
|
||||
payload: payload,
|
||||
signature: signature,
|
||||
ttl: ttl
|
||||
)
|
||||
}
|
||||
|
||||
private func timestamp(_ date: Date) -> UInt64 {
|
||||
UInt64(date.timeIntervalSince1970 * 1000)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
struct BLEFileTransferHandlerTests {
|
||||
private final class Recorder {
|
||||
var localNickname = "Me"
|
||||
var peers: [PeerID: BLEPeerInfo] = [:]
|
||||
var signedName: String?
|
||||
var saveResult: URL? = URL(fileURLWithPath: "/tmp/files/incoming/sample.pdf")
|
||||
|
||||
var signedNameQueries: [PeerID] = []
|
||||
var trackedPackets: [BitchatPacket] = []
|
||||
var quotaReservations: [Int] = []
|
||||
var saveCalls: [(data: Data, preferredName: String?, subdirectory: String, fallbackExtension: String?, defaultPrefix: String)] = []
|
||||
var lastSeenUpdates: [PeerID] = []
|
||||
var deliveredMessages: [BitchatMessage] = []
|
||||
}
|
||||
|
||||
private let localPeerID = PeerID(str: "0102030405060708")
|
||||
private let remotePeerID = PeerID(str: "1122334455667788")
|
||||
|
||||
private func makeHandler(recorder: Recorder) -> BLEFileTransferHandler {
|
||||
let environment = BLEFileTransferHandlerEnvironment(
|
||||
localPeerID: { [localPeerID] in localPeerID },
|
||||
localNickname: { recorder.localNickname },
|
||||
peersSnapshot: { recorder.peers },
|
||||
signedSenderDisplayName: { _, peerID in
|
||||
recorder.signedNameQueries.append(peerID)
|
||||
return recorder.signedName
|
||||
},
|
||||
trackPacketSeen: { packet in
|
||||
recorder.trackedPackets.append(packet)
|
||||
},
|
||||
enforceStorageQuota: { reservingBytes in
|
||||
recorder.quotaReservations.append(reservingBytes)
|
||||
},
|
||||
saveIncomingFile: { data, preferredName, subdirectory, fallbackExtension, defaultPrefix in
|
||||
recorder.saveCalls.append((data, preferredName, subdirectory, fallbackExtension, defaultPrefix))
|
||||
return recorder.saveResult
|
||||
},
|
||||
updatePeerLastSeen: { peerID in
|
||||
recorder.lastSeenUpdates.append(peerID)
|
||||
},
|
||||
deliverMessage: { message in
|
||||
recorder.deliveredMessages.append(message)
|
||||
}
|
||||
)
|
||||
return BLEFileTransferHandler(environment: environment)
|
||||
}
|
||||
|
||||
@Test
|
||||
func broadcastFileFromVerifiedPeerIsSavedAndDelivered() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let content = Data("%PDF-1.7".utf8)
|
||||
let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: content)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.signedNameQueries.isEmpty)
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.quotaReservations == [content.count])
|
||||
#expect(recorder.saveCalls.count == 1)
|
||||
#expect(recorder.saveCalls.first?.data == content)
|
||||
#expect(recorder.saveCalls.first?.preferredName == "sample")
|
||||
#expect(recorder.saveCalls.first?.subdirectory == "files/incoming")
|
||||
#expect(recorder.saveCalls.first?.fallbackExtension == "pdf")
|
||||
#expect(recorder.saveCalls.first?.defaultPrefix == "file")
|
||||
#expect(recorder.lastSeenUpdates.isEmpty)
|
||||
#expect(recorder.deliveredMessages.count == 1)
|
||||
let message = recorder.deliveredMessages.first
|
||||
#expect(message?.sender == "Alice")
|
||||
#expect(message?.content == "[file] sample.pdf")
|
||||
#expect(message?.isPrivate == false)
|
||||
#expect(message?.senderPeerID == remotePeerID)
|
||||
#expect(message?.timestamp == Date(timeIntervalSince1970: 900))
|
||||
}
|
||||
|
||||
@Test
|
||||
func selfEchoIsDropped() throws {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(sender: localPeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8), ttl: 3)
|
||||
|
||||
handler.handle(packet, from: localPeerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func unknownPeerWithoutValidSignatureIsDropped() throws {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.signedNameQueries == [remotePeerID])
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func connectedUnverifiedPeerIsAccepted() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Bob", isVerified: false, isConnected: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
// Unlike public messages, file transfers accept connected-but-unverified peers.
|
||||
#expect(recorder.signedNameQueries.isEmpty)
|
||||
#expect(recorder.deliveredMessages.count == 1)
|
||||
#expect(recorder.deliveredMessages.first?.sender == "Bob")
|
||||
}
|
||||
|
||||
@Test
|
||||
func fileDirectedToAnotherPeerIsIgnored() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(
|
||||
sender: remotePeerID,
|
||||
mimeType: "application/pdf",
|
||||
content: Data("%PDF-1.7".utf8),
|
||||
recipientID: Data(hexString: "AABBCCDDEEFF0011")
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.quotaReservations.isEmpty)
|
||||
#expect(recorder.saveCalls.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func privateFileUpdatesLastSeenAndDeliversPrivateMessage() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(
|
||||
sender: remotePeerID,
|
||||
mimeType: "application/pdf",
|
||||
content: Data("%PDF-1.7".utf8),
|
||||
recipientID: Data(hexString: localPeerID.id)
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
// Directed transfers are not tracked for gossip sync.
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.lastSeenUpdates == [remotePeerID])
|
||||
#expect(recorder.deliveredMessages.count == 1)
|
||||
#expect(recorder.deliveredMessages.first?.isPrivate == true)
|
||||
}
|
||||
|
||||
@Test
|
||||
func malformedPayloadIsTrackedForSyncButDropped() {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = BitchatPacket(
|
||||
type: MessageType.fileTransfer.rawValue,
|
||||
senderID: Data(hexString: remotePeerID.id) ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: 900_000,
|
||||
payload: Data([0x01, 0x02, 0x03]),
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
// Sync tracking happens before payload validation, matching the original order.
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.quotaReservations.isEmpty)
|
||||
#expect(recorder.saveCalls.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func unsupportedMimeIsDroppedBeforeQuotaAndSave() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: nil, content: Data([0x4D, 0x5A, 0x00, 0x00]))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.quotaReservations.isEmpty)
|
||||
#expect(recorder.saveCalls.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func saveFailureSkipsDelivery() throws {
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
recorder.saveResult = nil
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = try makeFileTransferPacket(sender: remotePeerID, mimeType: "application/pdf", content: Data("%PDF-1.7".utf8))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.quotaReservations.count == 1)
|
||||
#expect(recorder.saveCalls.count == 1)
|
||||
#expect(recorder.lastSeenUpdates.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
private func expectNoSideEffects(_ recorder: Recorder) {
|
||||
#expect(recorder.signedNameQueries.isEmpty)
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.quotaReservations.isEmpty)
|
||||
#expect(recorder.saveCalls.isEmpty)
|
||||
#expect(recorder.lastSeenUpdates.isEmpty)
|
||||
#expect(recorder.deliveredMessages.isEmpty)
|
||||
}
|
||||
|
||||
private func makePeerInfo(
|
||||
_ peerID: PeerID,
|
||||
nickname: String,
|
||||
isVerified: Bool,
|
||||
isConnected: Bool = true
|
||||
) -> BLEPeerInfo {
|
||||
BLEPeerInfo(
|
||||
peerID: peerID,
|
||||
nickname: nickname,
|
||||
isConnected: isConnected,
|
||||
noisePublicKey: nil,
|
||||
signingPublicKey: nil,
|
||||
isVerifiedNickname: isVerified,
|
||||
lastSeen: Date(timeIntervalSince1970: 999)
|
||||
)
|
||||
}
|
||||
|
||||
private func makeFileTransferPacket(
|
||||
sender: PeerID,
|
||||
mimeType: String?,
|
||||
content: Data,
|
||||
ttl: UInt8 = TransportConfig.messageTTLDefault,
|
||||
recipientID: Data? = nil
|
||||
) throws -> BitchatPacket {
|
||||
let filePacket = BitchatFilePacket(
|
||||
fileName: "sample",
|
||||
fileSize: UInt64(content.count),
|
||||
mimeType: mimeType,
|
||||
content: content
|
||||
)
|
||||
let payload = try #require(filePacket.encode())
|
||||
return BitchatPacket(
|
||||
type: MessageType.fileTransfer.rawValue,
|
||||
senderID: Data(hexString: sender.id) ?? Data(),
|
||||
recipientID: recipientID,
|
||||
timestamp: 900_000,
|
||||
payload: payload,
|
||||
signature: nil,
|
||||
ttl: ttl
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,227 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
struct BLEFragmentHandlerTests {
|
||||
private final class Recorder {
|
||||
/// Optional override for the assembly result; defaults to `.stored`.
|
||||
var appendResult: ((BLEFragmentHeader) -> BLEFragmentAssemblyBuffer.AppendResult)?
|
||||
var accepted = true
|
||||
|
||||
var trackedPackets: [BitchatPacket] = []
|
||||
var appendedHeaders: [BLEFragmentHeader] = []
|
||||
var ingressChecks: [(packet: BitchatPacket, innerSender: PeerID)] = []
|
||||
var reinjectedPackets: [(packet: BitchatPacket, from: PeerID)] = []
|
||||
}
|
||||
|
||||
private let localPeerID = PeerID(str: "0102030405060708")
|
||||
private let remotePeerID = PeerID(str: "1122334455667788")
|
||||
|
||||
private func makeHandler(recorder: Recorder) -> BLEFragmentHandler {
|
||||
let environment = BLEFragmentHandlerEnvironment(
|
||||
localPeerID: { [localPeerID] in localPeerID },
|
||||
trackPacketSeen: { packet in
|
||||
recorder.trackedPackets.append(packet)
|
||||
},
|
||||
appendFragment: { header in
|
||||
recorder.appendedHeaders.append(header)
|
||||
return recorder.appendResult?(header) ?? .stored(header: header, started: true)
|
||||
},
|
||||
isAcceptedIngressPayload: { packet, innerSender in
|
||||
recorder.ingressChecks.append((packet, innerSender))
|
||||
return recorder.accepted
|
||||
},
|
||||
processReassembledPacket: { packet, from in
|
||||
recorder.reinjectedPackets.append((packet, from))
|
||||
}
|
||||
)
|
||||
return BLEFragmentHandler(environment: environment)
|
||||
}
|
||||
|
||||
@Test
|
||||
func ownFragmentIsIgnored() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(sender: localPeerID, index: 0, total: 2)
|
||||
|
||||
handler.handle(packet, from: localPeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.appendedHeaders.isEmpty)
|
||||
#expect(recorder.reinjectedPackets.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func malformedFragmentPayloadIsIgnored() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = BitchatPacket(
|
||||
type: MessageType.fragment.rawValue,
|
||||
senderID: Data(hexString: remotePeerID.id) ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: 900_000,
|
||||
payload: Data([0x01, 0x02, 0x03]),
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.appendedHeaders.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func broadcastFragmentIsTrackedAndAppended() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let chunk = Data([0xDE, 0xAD, 0xBE, 0xEF])
|
||||
let packet = makeFragmentPacket(sender: remotePeerID, index: 0, total: 3, chunk: chunk)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.appendedHeaders.count == 1)
|
||||
#expect(recorder.appendedHeaders.first?.index == 0)
|
||||
#expect(recorder.appendedHeaders.first?.total == 3)
|
||||
#expect(recorder.appendedHeaders.first?.originalType == MessageType.message.rawValue)
|
||||
#expect(recorder.appendedHeaders.first?.fragmentData == chunk)
|
||||
#expect(recorder.ingressChecks.isEmpty)
|
||||
#expect(recorder.reinjectedPackets.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func directedFragmentIsNotTrackedForSync() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(
|
||||
sender: remotePeerID,
|
||||
index: 1,
|
||||
total: 3,
|
||||
recipientID: Data(hexString: localPeerID.id)
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.appendedHeaders.count == 1)
|
||||
}
|
||||
|
||||
@Test
|
||||
func completedReassemblyReinjectsAcceptedPacketWithZeroTTL() throws {
|
||||
let innerSender = PeerID(str: "99AABBCCDDEEFF00")
|
||||
let innerPacket = BitchatPacket(
|
||||
type: MessageType.message.rawValue,
|
||||
senderID: Data(hexString: innerSender.id) ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: 900_000,
|
||||
payload: Data("hello".utf8),
|
||||
signature: nil,
|
||||
ttl: 5
|
||||
)
|
||||
let reassembled = try #require(innerPacket.toBinaryData())
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.appendResult = { header in
|
||||
.complete(header: header, reassembledData: reassembled, started: false)
|
||||
}
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(sender: remotePeerID, index: 1, total: 2)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.ingressChecks.count == 1)
|
||||
#expect(recorder.ingressChecks.first?.innerSender == innerSender)
|
||||
#expect(recorder.reinjectedPackets.count == 1)
|
||||
let reinjected = recorder.reinjectedPackets.first
|
||||
#expect(reinjected?.from == remotePeerID)
|
||||
#expect(reinjected?.packet.type == MessageType.message.rawValue)
|
||||
#expect(reinjected?.packet.payload == Data("hello".utf8))
|
||||
// Reassembled packets must re-enter the pipeline with TTL zeroed.
|
||||
#expect(reinjected?.packet.ttl == 0)
|
||||
}
|
||||
|
||||
@Test
|
||||
func rejectedReassembledPacketIsNotReinjected() throws {
|
||||
let innerPacket = BitchatPacket(
|
||||
type: MessageType.message.rawValue,
|
||||
senderID: Data(hexString: "99AABBCCDDEEFF00") ?? Data(),
|
||||
recipientID: nil,
|
||||
timestamp: 900_000,
|
||||
payload: Data("hello".utf8),
|
||||
signature: nil,
|
||||
ttl: 5
|
||||
)
|
||||
let reassembled = try #require(innerPacket.toBinaryData())
|
||||
|
||||
let recorder = Recorder()
|
||||
recorder.accepted = false
|
||||
recorder.appendResult = { header in
|
||||
.complete(header: header, reassembledData: reassembled, started: false)
|
||||
}
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(sender: remotePeerID, index: 1, total: 2)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.ingressChecks.count == 1)
|
||||
#expect(recorder.reinjectedPackets.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func undecodableReassembledDataIsDropped() {
|
||||
let recorder = Recorder()
|
||||
recorder.appendResult = { header in
|
||||
.complete(header: header, reassembledData: Data([0x00, 0x01]), started: false)
|
||||
}
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(sender: remotePeerID, index: 1, total: 2)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.ingressChecks.isEmpty)
|
||||
#expect(recorder.reinjectedPackets.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func incompleteAssemblyDoesNotReinject() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeFragmentPacket(sender: remotePeerID, index: 0, total: 2)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.appendedHeaders.count == 1)
|
||||
#expect(recorder.ingressChecks.isEmpty)
|
||||
#expect(recorder.reinjectedPackets.isEmpty)
|
||||
}
|
||||
|
||||
private func makeFragmentPacket(
|
||||
sender: PeerID,
|
||||
index: UInt16,
|
||||
total: UInt16,
|
||||
originalType: UInt8 = MessageType.message.rawValue,
|
||||
chunk: Data = Data([0xAA, 0xBB]),
|
||||
recipientID: Data? = nil
|
||||
) -> BitchatPacket {
|
||||
var payload = Data()
|
||||
payload.append(contentsOf: [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77]) // fragment ID
|
||||
payload.append(UInt8(index >> 8))
|
||||
payload.append(UInt8(index & 0xFF))
|
||||
payload.append(UInt8(total >> 8))
|
||||
payload.append(UInt8(total & 0xFF))
|
||||
payload.append(originalType)
|
||||
payload.append(chunk)
|
||||
|
||||
return BitchatPacket(
|
||||
type: MessageType.fragment.rawValue,
|
||||
senderID: Data(hexString: sender.id) ?? Data(),
|
||||
recipientID: recipientID,
|
||||
timestamp: 900_000,
|
||||
payload: payload,
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,310 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
struct BLENoisePacketHandlerTests {
|
||||
private struct TestError: Error {}
|
||||
|
||||
private final class Recorder {
|
||||
var handshakeResult: Result<Data?, Error> = .success(nil)
|
||||
var hasSession = false
|
||||
var decryptResult: Result<Data, Error> = .success(Data())
|
||||
|
||||
var processedHandshakes: [(peerID: PeerID, message: Data)] = []
|
||||
var hasSessionQueries: [PeerID] = []
|
||||
var initiatedHandshakes: [PeerID] = []
|
||||
var broadcastPackets: [BitchatPacket] = []
|
||||
var lastSeenUpdates: [PeerID] = []
|
||||
var decryptCalls: [(payload: Data, peerID: PeerID)] = []
|
||||
var clearedSessions: [PeerID] = []
|
||||
var deliveries: [(peerID: PeerID, type: NoisePayloadType, payload: Data, timestamp: Date)] = []
|
||||
/// Ordered side-effect log to assert recovery sequencing.
|
||||
var events: [String] = []
|
||||
}
|
||||
|
||||
private let localPeerID = PeerID(str: "0102030405060708")
|
||||
private let remotePeerID = PeerID(str: "1122334455667788")
|
||||
private let localPeerIDData = Data(hexString: "0102030405060708") ?? Data()
|
||||
|
||||
private func makeHandler(
|
||||
recorder: Recorder,
|
||||
now: Date = Date(timeIntervalSince1970: 1_000)
|
||||
) -> BLENoisePacketHandler {
|
||||
let environment = BLENoisePacketHandlerEnvironment(
|
||||
localPeerID: { [localPeerID] in localPeerID },
|
||||
localPeerIDData: { [localPeerIDData] in localPeerIDData },
|
||||
messageTTL: TransportConfig.messageTTLDefault,
|
||||
now: { now },
|
||||
processHandshakeMessage: { peerID, message in
|
||||
recorder.processedHandshakes.append((peerID, message))
|
||||
return try recorder.handshakeResult.get()
|
||||
},
|
||||
hasNoiseSession: { peerID in
|
||||
recorder.hasSessionQueries.append(peerID)
|
||||
return recorder.hasSession
|
||||
},
|
||||
initiateHandshake: { peerID in
|
||||
recorder.initiatedHandshakes.append(peerID)
|
||||
recorder.events.append("initiateHandshake")
|
||||
},
|
||||
broadcastPacket: { packet in
|
||||
recorder.broadcastPackets.append(packet)
|
||||
},
|
||||
updatePeerLastSeen: { peerID in
|
||||
recorder.lastSeenUpdates.append(peerID)
|
||||
},
|
||||
decrypt: { payload, peerID in
|
||||
recorder.decryptCalls.append((payload, peerID))
|
||||
return try recorder.decryptResult.get()
|
||||
},
|
||||
clearSession: { peerID in
|
||||
recorder.clearedSessions.append(peerID)
|
||||
recorder.events.append("clearSession")
|
||||
},
|
||||
deliverNoisePayload: { peerID, type, payload, timestamp in
|
||||
recorder.deliveries.append((peerID, type, payload, timestamp))
|
||||
}
|
||||
)
|
||||
return BLENoisePacketHandler(environment: environment)
|
||||
}
|
||||
|
||||
// MARK: Handshake
|
||||
|
||||
@Test
|
||||
func handshakeForUsBroadcastsResponsePacket() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.handshakeResult = .success(Data([0xAA, 0xBB]))
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeHandshakePacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleHandshake(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.processedHandshakes.count == 1)
|
||||
#expect(recorder.processedHandshakes.first?.peerID == remotePeerID)
|
||||
#expect(recorder.processedHandshakes.first?.message == packet.payload)
|
||||
#expect(recorder.broadcastPackets.count == 1)
|
||||
let response = recorder.broadcastPackets.first
|
||||
#expect(response?.type == MessageType.noiseHandshake.rawValue)
|
||||
#expect(response?.senderID == localPeerIDData)
|
||||
#expect(response?.recipientID == Data(hexString: remotePeerID.id))
|
||||
#expect(response?.payload == Data([0xAA, 0xBB]))
|
||||
#expect(response?.signature == nil)
|
||||
#expect(response?.ttl == TransportConfig.messageTTLDefault)
|
||||
#expect(response?.timestamp == UInt64(now.timeIntervalSince1970 * 1000))
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func handshakeWithoutResponseDoesNotBroadcast() {
|
||||
let recorder = Recorder()
|
||||
recorder.handshakeResult = .success(nil)
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeHandshakePacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleHandshake(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.processedHandshakes.count == 1)
|
||||
#expect(recorder.broadcastPackets.isEmpty)
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func handshakeForAnotherPeerIsIgnored() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeHandshakePacket(recipientID: Data(hexString: remotePeerID.id))
|
||||
|
||||
handler.handleHandshake(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.processedHandshakes.isEmpty)
|
||||
#expect(recorder.broadcastPackets.isEmpty)
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func handshakeFailureInitiatesNewHandshakeWhenNoSession() {
|
||||
let recorder = Recorder()
|
||||
recorder.handshakeResult = .failure(TestError())
|
||||
recorder.hasSession = false
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeHandshakePacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleHandshake(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.hasSessionQueries == [remotePeerID])
|
||||
#expect(recorder.initiatedHandshakes == [remotePeerID])
|
||||
#expect(recorder.broadcastPackets.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func handshakeFailureSkipsInitiateWhenSessionExists() {
|
||||
let recorder = Recorder()
|
||||
recorder.handshakeResult = .failure(TestError())
|
||||
recorder.hasSession = true
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeHandshakePacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleHandshake(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.hasSessionQueries == [remotePeerID])
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: Encrypted
|
||||
|
||||
@Test
|
||||
func encryptedWithoutRecipientIsDropped() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: nil)
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.lastSeenUpdates.isEmpty)
|
||||
#expect(recorder.decryptCalls.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func encryptedForAnotherPeerIsDropped() {
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: remotePeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.lastSeenUpdates.isEmpty)
|
||||
#expect(recorder.decryptCalls.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func decryptedPayloadIsDeliveredWithTypeAndTimestamp() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .success(Data([NoisePayloadType.privateMessage.rawValue, 0x01, 0x02, 0x03]))
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let sentAt = Date(timeIntervalSince1970: 900)
|
||||
let packet = makeEncryptedPacket(
|
||||
recipientID: Data(hexString: localPeerID.id),
|
||||
timestamp: UInt64(sentAt.timeIntervalSince1970 * 1000)
|
||||
)
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.lastSeenUpdates == [remotePeerID])
|
||||
#expect(recorder.decryptCalls.count == 1)
|
||||
#expect(recorder.decryptCalls.first?.payload == packet.payload)
|
||||
#expect(recorder.deliveries.count == 1)
|
||||
#expect(recorder.deliveries.first?.peerID == remotePeerID)
|
||||
#expect(recorder.deliveries.first?.type == .privateMessage)
|
||||
#expect(recorder.deliveries.first?.payload == Data([0x01, 0x02, 0x03]))
|
||||
#expect(recorder.deliveries.first?.timestamp == sentAt)
|
||||
#expect(recorder.clearedSessions.isEmpty)
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func emptyDecryptedPayloadIsIgnored() {
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .success(Data())
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.decryptCalls.count == 1)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
#expect(recorder.clearedSessions.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func unknownNoisePayloadTypeIsIgnored() {
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .success(Data([0xEE, 0x01]))
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.decryptCalls.count == 1)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func missingSessionInitiatesHandshakeWithoutClearing() {
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .failure(NoiseEncryptionError.sessionNotEstablished)
|
||||
recorder.hasSession = false
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.hasSessionQueries == [remotePeerID])
|
||||
#expect(recorder.initiatedHandshakes == [remotePeerID])
|
||||
#expect(recorder.clearedSessions.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func missingSessionSkipsInitiateWhenSessionAppeared() {
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .failure(NoiseEncryptionError.sessionNotEstablished)
|
||||
recorder.hasSession = true
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.initiatedHandshakes.isEmpty)
|
||||
#expect(recorder.clearedSessions.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func decryptFailureClearsSessionThenReinitiatesHandshake() {
|
||||
let recorder = Recorder()
|
||||
recorder.decryptResult = .failure(TestError())
|
||||
// Even with a live session, recovery clears it and re-initiates unconditionally.
|
||||
recorder.hasSession = true
|
||||
let handler = makeHandler(recorder: recorder)
|
||||
let packet = makeEncryptedPacket(recipientID: Data(hexString: localPeerID.id))
|
||||
|
||||
handler.handleEncrypted(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.clearedSessions == [remotePeerID])
|
||||
#expect(recorder.initiatedHandshakes == [remotePeerID])
|
||||
// Session-recovery order must stay clear → re-initiate.
|
||||
#expect(recorder.events == ["clearSession", "initiateHandshake"])
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
private func makeHandshakePacket(recipientID: Data?) -> BitchatPacket {
|
||||
BitchatPacket(
|
||||
type: MessageType.noiseHandshake.rawValue,
|
||||
senderID: Data(hexString: remotePeerID.id) ?? Data(),
|
||||
recipientID: recipientID,
|
||||
timestamp: 900_000,
|
||||
payload: Data([0x01, 0x02, 0x03]),
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
}
|
||||
|
||||
private func makeEncryptedPacket(
|
||||
recipientID: Data?,
|
||||
timestamp: UInt64 = 900_000
|
||||
) -> BitchatPacket {
|
||||
BitchatPacket(
|
||||
type: MessageType.noiseEncrypted.rawValue,
|
||||
senderID: Data(hexString: remotePeerID.id) ?? Data(),
|
||||
recipientID: recipientID,
|
||||
timestamp: timestamp,
|
||||
payload: Data([0xC0, 0xFF, 0xEE]),
|
||||
signature: nil,
|
||||
ttl: TransportConfig.messageTTLDefault
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,251 @@
|
||||
import BitFoundation
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import bitchat
|
||||
|
||||
struct BLEPublicMessageHandlerTests {
|
||||
private final class Recorder {
|
||||
var localNickname = "Me"
|
||||
var peers: [PeerID: BLEPeerInfo] = [:]
|
||||
var signedName: String?
|
||||
var linkState: (hasPeripheral: Bool, hasCentral: Bool) = (false, false)
|
||||
var selfBroadcastMessageID: String?
|
||||
|
||||
var peersSnapshotReads = 0
|
||||
var signedNameQueries: [PeerID] = []
|
||||
var trackedPackets: [BitchatPacket] = []
|
||||
var selfBroadcastTakes: [BitchatPacket] = []
|
||||
var deliveries: [(peerID: PeerID, nickname: String, content: String, timestamp: Date, messageID: String?)] = []
|
||||
}
|
||||
|
||||
private let localPeerID = PeerID(str: "0102030405060708")
|
||||
private let remotePeerID = PeerID(str: "1122334455667788")
|
||||
|
||||
private func makeHandler(
|
||||
recorder: Recorder,
|
||||
localPeerID: PeerID? = nil,
|
||||
now: Date = Date(timeIntervalSince1970: 1_000)
|
||||
) -> BLEPublicMessageHandler {
|
||||
let resolvedLocalPeerID = localPeerID ?? self.localPeerID
|
||||
let environment = BLEPublicMessageHandlerEnvironment(
|
||||
localPeerID: { resolvedLocalPeerID },
|
||||
localNickname: { recorder.localNickname },
|
||||
now: { now },
|
||||
peersSnapshot: {
|
||||
recorder.peersSnapshotReads += 1
|
||||
return recorder.peers
|
||||
},
|
||||
signedSenderDisplayName: { _, peerID in
|
||||
recorder.signedNameQueries.append(peerID)
|
||||
return recorder.signedName
|
||||
},
|
||||
trackPacketSeen: { packet in
|
||||
recorder.trackedPackets.append(packet)
|
||||
},
|
||||
linkState: { _ in recorder.linkState },
|
||||
takeSelfBroadcastMessageID: { packet in
|
||||
recorder.selfBroadcastTakes.append(packet)
|
||||
return recorder.selfBroadcastMessageID
|
||||
},
|
||||
deliverPublicMessage: { peerID, nickname, content, timestamp, messageID in
|
||||
recorder.deliveries.append((peerID, nickname, content, timestamp, messageID))
|
||||
}
|
||||
)
|
||||
return BLEPublicMessageHandler(environment: environment)
|
||||
}
|
||||
|
||||
@Test
|
||||
func verifiedPeerBroadcastIsTrackedAndDelivered() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, content: "hello mesh", timestamp: timestamp(now))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.peersSnapshotReads == 1)
|
||||
#expect(recorder.signedNameQueries.isEmpty)
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.selfBroadcastTakes.isEmpty)
|
||||
#expect(recorder.deliveries.count == 1)
|
||||
#expect(recorder.deliveries.first?.peerID == remotePeerID)
|
||||
#expect(recorder.deliveries.first?.nickname == "Alice")
|
||||
#expect(recorder.deliveries.first?.content == "hello mesh")
|
||||
#expect(recorder.deliveries.first?.timestamp == now)
|
||||
#expect(recorder.deliveries.first?.messageID == nil)
|
||||
}
|
||||
|
||||
@Test
|
||||
func selfEchoIsDropped() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: localPeerID, content: "echo", timestamp: timestamp(now), ttl: 3)
|
||||
|
||||
handler.handle(packet, from: localPeerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func staleBroadcastIsDropped() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let staleTimestamp = UInt64((now.timeIntervalSince1970 - 901) * 1000)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, content: "old", timestamp: staleTimestamp)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
expectNoSideEffects(recorder)
|
||||
}
|
||||
|
||||
@Test
|
||||
func unknownPeerWithoutValidSignatureIsDroppedBeforeSyncTracking() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, content: "hi", timestamp: timestamp(now))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.signedNameQueries == [remotePeerID])
|
||||
// The sender must resolve before the packet is tracked for sync.
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func connectedButUnverifiedPeerIsDropped() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Mallory", isVerified: false, isConnected: true)]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, content: "hi", timestamp: timestamp(now))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
// Public messages never accept connected-but-unverified registry entries.
|
||||
#expect(recorder.signedNameQueries == [remotePeerID])
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func signedSenderFallbackDeliversWithSignedName() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.signedName = "SignedAlice"
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, content: "signed hello", timestamp: timestamp(now))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.signedNameQueries == [remotePeerID])
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.deliveries.count == 1)
|
||||
#expect(recorder.deliveries.first?.nickname == "SignedAlice")
|
||||
}
|
||||
|
||||
@Test
|
||||
func invalidUTF8PayloadIsTrackedForSyncButNotDelivered() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(sender: remotePeerID, payload: Data([0xFF, 0xFE, 0xFD]), timestamp: timestamp(now))
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
// Sync tracking happens before payload decoding, matching the original order.
|
||||
#expect(recorder.trackedPackets.count == 1)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
@Test
|
||||
func selfSyncReplayResolvesOriginalMessageID() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.selfBroadcastMessageID = "original-id"
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
// TTL 0 marks a sync replay of our own broadcast, not a self echo.
|
||||
let packet = makeMessagePacket(sender: localPeerID, content: "mine", timestamp: timestamp(now), ttl: 0)
|
||||
|
||||
handler.handle(packet, from: localPeerID)
|
||||
|
||||
#expect(recorder.selfBroadcastTakes.count == 1)
|
||||
#expect(recorder.deliveries.count == 1)
|
||||
#expect(recorder.deliveries.first?.peerID == localPeerID)
|
||||
#expect(recorder.deliveries.first?.nickname == recorder.localNickname)
|
||||
#expect(recorder.deliveries.first?.messageID == "original-id")
|
||||
}
|
||||
|
||||
@Test
|
||||
func directedMessageIsDeliveredWithoutSyncTracking() {
|
||||
let now = Date(timeIntervalSince1970: 1_000)
|
||||
let recorder = Recorder()
|
||||
recorder.peers = [remotePeerID: makePeerInfo(remotePeerID, nickname: "Alice", isVerified: true)]
|
||||
let handler = makeHandler(recorder: recorder, now: now)
|
||||
let packet = makeMessagePacket(
|
||||
sender: remotePeerID,
|
||||
content: "direct",
|
||||
timestamp: timestamp(now),
|
||||
recipientID: Data(hexString: localPeerID.id)
|
||||
)
|
||||
|
||||
handler.handle(packet, from: remotePeerID)
|
||||
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.deliveries.count == 1)
|
||||
#expect(recorder.deliveries.first?.content == "direct")
|
||||
}
|
||||
|
||||
private func expectNoSideEffects(_ recorder: Recorder) {
|
||||
#expect(recorder.signedNameQueries.isEmpty)
|
||||
#expect(recorder.trackedPackets.isEmpty)
|
||||
#expect(recorder.selfBroadcastTakes.isEmpty)
|
||||
#expect(recorder.deliveries.isEmpty)
|
||||
}
|
||||
|
||||
private func makePeerInfo(
|
||||
_ peerID: PeerID,
|
||||
nickname: String,
|
||||
isVerified: Bool,
|
||||
isConnected: Bool = true
|
||||
) -> BLEPeerInfo {
|
||||
BLEPeerInfo(
|
||||
peerID: peerID,
|
||||
nickname: nickname,
|
||||
isConnected: isConnected,
|
||||
noisePublicKey: nil,
|
||||
signingPublicKey: nil,
|
||||
isVerifiedNickname: isVerified,
|
||||
lastSeen: Date(timeIntervalSince1970: 999)
|
||||
)
|
||||
}
|
||||
|
||||
private func makeMessagePacket(
|
||||
sender: PeerID,
|
||||
content: String? = nil,
|
||||
payload: Data? = nil,
|
||||
timestamp: UInt64,
|
||||
ttl: UInt8 = TransportConfig.messageTTLDefault,
|
||||
recipientID: Data? = nil
|
||||
) -> BitchatPacket {
|
||||
BitchatPacket(
|
||||
type: MessageType.message.rawValue,
|
||||
senderID: Data(hexString: sender.id) ?? Data(),
|
||||
recipientID: recipientID,
|
||||
timestamp: timestamp,
|
||||
payload: payload ?? Data((content ?? "").utf8),
|
||||
signature: nil,
|
||||
ttl: ttl
|
||||
)
|
||||
}
|
||||
|
||||
private func timestamp(_ date: Date) -> UInt64 {
|
||||
UInt64(date.timeIntervalSince1970 * 1000)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user