mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-25 23:45:20 +00:00
2190 lines
75 KiB
Swift
2190 lines
75 KiB
Swift
//
|
|
// ChatViewModelTests.swift
|
|
// bitchatTests
|
|
//
|
|
// Tests for ChatViewModel using MockTransport for isolation.
|
|
// This is free and unencumbered software released into the public domain.
|
|
//
|
|
|
|
import Testing
|
|
import Foundation
|
|
import BitFoundation
|
|
@testable import bitchat
|
|
|
|
// MARK: - Test Helpers
|
|
|
|
/// Creates a ChatViewModel with mock dependencies for testing
|
|
@MainActor
|
|
private func makeTestableViewModel(
|
|
keychain injectedKeychain: MockKeychain? = nil,
|
|
panicMediaWipe: (() throws -> Void)? = nil,
|
|
panicRecoveryOperations: PanicRecoveryOperations? = nil,
|
|
panicNetworkLifecycle: PanicNetworkLifecycle = .noop
|
|
) -> (viewModel: ChatViewModel, transport: MockTransport) {
|
|
let keychain = injectedKeychain ?? MockKeychain()
|
|
let keychainHelper = MockKeychainHelper()
|
|
let idBridge = NostrIdentityBridge(keychain: keychainHelper)
|
|
let identityManager = MockIdentityManager(keychain)
|
|
let transport = MockTransport()
|
|
|
|
let viewModel = ChatViewModel(
|
|
keychain: keychain,
|
|
idBridge: idBridge,
|
|
identityManager: identityManager,
|
|
transport: transport,
|
|
panicMediaWipe: panicMediaWipe,
|
|
panicRecoveryOperations: panicRecoveryOperations,
|
|
panicNetworkLifecycle: panicNetworkLifecycle
|
|
)
|
|
|
|
return (viewModel, transport)
|
|
}
|
|
|
|
// MARK: - Initialization Tests
|
|
|
|
struct ChatViewModelInitializationTests {
|
|
|
|
@Test @MainActor
|
|
func initialization_setsDelegate() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
// The viewModel should set itself as the transport delegate
|
|
#expect(transport.delegate === viewModel)
|
|
#expect(transport.eventDelegate === viewModel)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func initialization_startsServices() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
|
|
// Services should be started during init
|
|
#expect(transport.startServicesCallCount == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func initialization_hasEmptyMessageList() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
// Initial messages may include system messages, but should be limited
|
|
#expect(viewModel.messages.count < 10)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func initialization_setsNickname() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
|
|
// Nickname should be set during init
|
|
#expect(!transport.myNickname.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func initialization_bindsPeerSnapshotsIntoAllPeers() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "00000000000000a1")
|
|
let noiseKey = Data(repeating: 0xAB, count: 32)
|
|
|
|
transport.updatePeerSnapshots([
|
|
TransportPeerSnapshot(
|
|
peerID: peerID,
|
|
nickname: "Alice",
|
|
isConnected: true,
|
|
noisePublicKey: noiseKey,
|
|
lastSeen: Date()
|
|
)
|
|
])
|
|
|
|
// The snapshot → allPeers binding hops the transport's unstructured
|
|
// Task, UnifiedPeerService, a receive(on: main), and another Task —
|
|
// all contending with every parallel worker, so a loaded CI runner
|
|
// can exceed defaultTimeout (observed: one 5s miss on a run where
|
|
// the whole suite took 10s instead of the usual ~4s).
|
|
let updated = await TestHelpers.waitUntil({
|
|
viewModel.allPeers.contains { $0.peerID == peerID && $0.nickname == "Alice" }
|
|
}, timeout: TestConstants.longTimeout)
|
|
|
|
#expect(updated)
|
|
}
|
|
}
|
|
|
|
// MARK: - Identity Tests
|
|
|
|
struct ChatViewModelIdentityTests {
|
|
|
|
@Test @MainActor
|
|
func updatePrivateChatPeerIfNeeded_migratesSelectionHistoryByFingerprint() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let oldPeerID = PeerID(str: "00000000000000d1")
|
|
let newPeerID = PeerID(str: "00000000000000d2")
|
|
let sharedFingerprint = "fingerprint-shared"
|
|
let sharedNoiseKey = Data(repeating: 0xAB, count: 32)
|
|
|
|
transport.peerFingerprints[oldPeerID] = sharedFingerprint
|
|
transport.peerFingerprints[newPeerID] = sharedFingerprint
|
|
transport.peerNicknames[oldPeerID] = "Alice"
|
|
transport.peerNicknames[newPeerID] = "Alice"
|
|
transport.updatePeerSnapshots([
|
|
TransportPeerSnapshot(
|
|
peerID: oldPeerID,
|
|
nickname: "Alice",
|
|
isConnected: true,
|
|
noisePublicKey: sharedNoiseKey,
|
|
lastSeen: Date()
|
|
)
|
|
])
|
|
|
|
// Same multi-hop snapshot pipeline as above: longTimeout for load.
|
|
let oldPeerBound = await TestHelpers.waitUntil({
|
|
viewModel.connectedPeers.contains(oldPeerID)
|
|
}, timeout: TestConstants.longTimeout)
|
|
#expect(oldPeerBound)
|
|
|
|
let existingMessage = BitchatMessage(
|
|
id: "pm-migrate-1",
|
|
sender: "Alice",
|
|
content: "Still here",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: oldPeerID,
|
|
mentions: nil
|
|
)
|
|
viewModel.seedPrivateChat([existingMessage], for: oldPeerID)
|
|
viewModel.startPrivateChat(with: oldPeerID)
|
|
|
|
#expect(viewModel.selectedPrivateChatPeer == oldPeerID)
|
|
#expect(viewModel.hasTrackedPrivateChatSelection)
|
|
#expect(viewModel.selectedPrivateChatFingerprint == viewModel.getFingerprint(for: oldPeerID))
|
|
|
|
transport.updatePeerSnapshots([
|
|
TransportPeerSnapshot(
|
|
peerID: newPeerID,
|
|
nickname: "Alice",
|
|
isConnected: true,
|
|
noisePublicKey: sharedNoiseKey,
|
|
lastSeen: Date()
|
|
)
|
|
])
|
|
|
|
let newPeerBound = await TestHelpers.waitUntil({
|
|
viewModel.connectedPeers.contains(newPeerID) && !viewModel.connectedPeers.contains(oldPeerID)
|
|
}, timeout: TestConstants.longTimeout)
|
|
#expect(newPeerBound)
|
|
|
|
viewModel.updatePrivateChatPeerIfNeeded()
|
|
|
|
#expect(viewModel.selectedPrivateChatPeer == newPeerID)
|
|
#expect(viewModel.privateChats[oldPeerID] == nil)
|
|
#expect(viewModel.privateChats[newPeerID]?.contains(where: { $0.id == "pm-migrate-1" }) == true)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func resolveNickname_prefersLocalPetnameOverClaimedNickname() async {
|
|
let keychain = MockKeychain()
|
|
let keychainHelper = MockKeychainHelper()
|
|
let idBridge = NostrIdentityBridge(keychain: keychainHelper)
|
|
let identityManager = MockIdentityManager(keychain)
|
|
let transport = MockTransport()
|
|
let viewModel = ChatViewModel(
|
|
keychain: keychain,
|
|
idBridge: idBridge,
|
|
identityManager: identityManager,
|
|
transport: transport
|
|
)
|
|
let peerID = PeerID(str: "00000000000000d3")
|
|
let fingerprint = "fingerprint-petname"
|
|
|
|
transport.peerFingerprints[peerID] = fingerprint
|
|
identityManager.updateSocialIdentity(
|
|
SocialIdentity(
|
|
fingerprint: fingerprint,
|
|
localPetname: "Buddy",
|
|
claimedNickname: "Alice",
|
|
trustLevel: .trusted,
|
|
isFavorite: false,
|
|
isBlocked: false,
|
|
notes: nil
|
|
)
|
|
)
|
|
|
|
#expect(viewModel.getFingerprint(for: peerID) == fingerprint)
|
|
#expect(viewModel.resolveNickname(for: peerID) == "Buddy")
|
|
}
|
|
}
|
|
|
|
// MARK: - Message Sending Tests
|
|
|
|
struct ChatViewModelSendingTests {
|
|
|
|
@Test @MainActor
|
|
func sendMessage_delegatesToTransport() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
viewModel.sendMessage("Hello World")
|
|
|
|
#expect(transport.sentMessages.count == 1)
|
|
#expect(transport.sentMessages.first?.content == "Hello World")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendMessage_emptyContent_ignored() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
viewModel.sendMessage("")
|
|
viewModel.sendMessage(" ")
|
|
viewModel.sendMessage("\n\t")
|
|
|
|
#expect(transport.sentMessages.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendMessage_withMentions_sendsContent() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
viewModel.sendMessage("Hello @alice")
|
|
|
|
#expect(transport.sentMessages.count == 1)
|
|
#expect(transport.sentMessages.first?.content == "Hello @alice")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendMessage_command_notSentToTransport() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
viewModel.sendMessage("/help")
|
|
|
|
// Commands are processed locally, not sent to transport
|
|
#expect(transport.sentMessages.isEmpty)
|
|
}
|
|
}
|
|
|
|
// MARK: - Command Handling Tests
|
|
|
|
struct ChatViewModelCommandTests {
|
|
|
|
@Test @MainActor
|
|
func sendMessage_commandsNotSentToTransport() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let commands = ["/nick bob", "/who", "/help", "/clear"]
|
|
|
|
for command in commands {
|
|
transport.resetRecordings()
|
|
viewModel.sendMessage(command)
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
#expect(transport.sentMessages.isEmpty)
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
}
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleCommand_outputRoutesToOpenPrivateChat() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000002")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
|
|
viewModel.handleCommand("/help")
|
|
|
|
#expect(viewModel.privateChats[peerID]?.last?.content == CommandProcessor.helpText)
|
|
#expect(!viewModel.messages.contains { $0.content == CommandProcessor.helpText })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleCommand_errorRoutesToOpenPrivateChat() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000002")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
|
|
viewModel.handleCommand("/bogus")
|
|
|
|
let dmContents = viewModel.privateChats[peerID]?.map(\.content) ?? []
|
|
#expect(dmContents.contains { $0.hasPrefix("unknown command: /bogus") })
|
|
#expect(!viewModel.messages.contains { $0.content.hasPrefix("unknown command: /bogus") })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleCommand_outputRoutesToPublicTimelineWithoutOpenDM() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
viewModel.handleCommand("/bogus")
|
|
|
|
#expect(viewModel.messages.last?.content.hasPrefix("unknown command: /bogus") == true)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleCommand_msgSuccessLandsInNewlyOpenedChat() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000002")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
let resolved = await TestHelpers.waitUntil({
|
|
viewModel.getPeerIDForNickname("Alice") == peerID
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
#expect(resolved)
|
|
|
|
viewModel.handleCommand("/msg Alice")
|
|
|
|
#expect(viewModel.selectedPrivateChatPeer == peerID)
|
|
#expect(viewModel.privateChats[peerID]?.last?.content == "started private chat with Alice")
|
|
#expect(!viewModel.messages.contains { $0.content == "started private chat with Alice" })
|
|
}
|
|
}
|
|
|
|
// MARK: - Composer Tests
|
|
|
|
struct ChatViewModelComposerTests {
|
|
|
|
@Test @MainActor
|
|
func updateAutocomplete_suggestsKnownPeersAndExcludesSelf() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let alice = PeerID(str: "00000000000000a1")
|
|
let selfAlias = PeerID(str: "00000000000000a2")
|
|
|
|
transport.simulateConnect(alice, nickname: "Alice")
|
|
transport.simulateConnect(selfAlias, nickname: viewModel.nickname)
|
|
|
|
viewModel.updateAutocomplete(for: "hello @Al", cursorPosition: 9)
|
|
|
|
#expect(viewModel.showAutocomplete)
|
|
#expect(viewModel.autocompleteSuggestions == ["@Alice"])
|
|
}
|
|
|
|
@Test @MainActor
|
|
func completeNickname_replacesTokenAndClearsAutocompleteState() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
var text = "hello @Al"
|
|
|
|
viewModel.autocompleteSuggestions = ["@Alice"]
|
|
viewModel.autocompleteRange = NSRange(location: 6, length: 3)
|
|
viewModel.showAutocomplete = true
|
|
viewModel.selectedAutocompleteIndex = 0
|
|
|
|
_ = viewModel.completeNickname("@Alice", in: &text)
|
|
|
|
#expect(text == "hello @Alice")
|
|
#expect(viewModel.autocompleteSuggestions.isEmpty)
|
|
#expect(viewModel.autocompleteRange == nil)
|
|
#expect(!viewModel.showAutocomplete)
|
|
#expect(viewModel.selectedAutocompleteIndex == 0)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func parseMentions_filtersToKnownPeerAndSelfTokens() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let alice = PeerID(str: "00000000000000b1")
|
|
|
|
transport.simulateConnect(alice, nickname: "Alice")
|
|
|
|
let mentions = Set(
|
|
viewModel.parseMentions(
|
|
from: "hi @Alice @nobody @\(viewModel.nickname)"
|
|
)
|
|
)
|
|
|
|
#expect(mentions.contains("Alice"))
|
|
#expect(mentions.contains(viewModel.nickname))
|
|
#expect(!mentions.contains("nobody"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Lifecycle Tests
|
|
|
|
struct ChatViewModelServiceLifecycleTests {
|
|
|
|
@Test @MainActor
|
|
func handleDidBecomeActive_marksVisiblePrivateMessagesAsRead() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000001")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
|
|
let message = BitchatMessage(
|
|
id: "read-1",
|
|
sender: "Alice",
|
|
content: "Hello from Alice",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID,
|
|
mentions: nil
|
|
)
|
|
|
|
viewModel.seedPrivateChat([message], for: peerID)
|
|
viewModel.markPrivateChatUnread(peerID)
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
|
|
viewModel.handleDidBecomeActive()
|
|
|
|
let sentReadReceipt = await TestHelpers.waitUntil({
|
|
transport.sentReadReceipts.contains {
|
|
$0.peerID == peerID && $0.receipt.originalMessageID == "read-1"
|
|
}
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(sentReadReceipt)
|
|
#expect(!viewModel.unreadPrivateMessages.contains(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleScreenshotCaptured_privateChatAddsLocalNoticeWithoutSession() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000002")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
viewModel.handleScreenshotCaptured()
|
|
|
|
#expect(transport.sentPrivateMessages.isEmpty)
|
|
#expect(viewModel.privateChats[peerID]?.last?.content == "you took a screenshot")
|
|
}
|
|
}
|
|
|
|
// MARK: - Timeline Cap Tests
|
|
|
|
struct ChatViewModelTimelineCapTests {
|
|
|
|
@Test @MainActor
|
|
func sendMessage_trimsTimelineToCap() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let total = TransportConfig.meshTimelineCap + 5
|
|
|
|
for i in 0..<total {
|
|
viewModel.sendMessage("cap-msg-\(i)")
|
|
}
|
|
|
|
#expect(viewModel.messages.count == TransportConfig.meshTimelineCap)
|
|
#expect(viewModel.messages.last?.content == "cap-msg-\(total - 1)")
|
|
}
|
|
}
|
|
|
|
// MARK: - Message Receiving Tests
|
|
|
|
struct ChatViewModelReceivingTests {
|
|
|
|
@Test @MainActor
|
|
func didReceiveMessage_callsDelegate() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
let message = BitchatMessage(
|
|
id: "msg-001",
|
|
sender: "Alice",
|
|
content: "Hello from Alice",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: false,
|
|
recipientNickname: nil,
|
|
senderPeerID: PeerID(str: "PEER001"),
|
|
mentions: nil
|
|
)
|
|
|
|
transport.simulateIncomingMessage(message)
|
|
|
|
// Give time for Task and pipeline processing
|
|
try? await Task.sleep(nanoseconds: 200_000_000)
|
|
|
|
// Message may or may not appear due to rate limiting/pipeline batching
|
|
// The important thing is no crash and delegate was called
|
|
#expect(transport.delegate === viewModel)
|
|
#expect(transport.eventDelegate === viewModel)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didReceivePublicMessage_addsToTimeline() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
transport.simulateIncomingPublicMessage(
|
|
from: PeerID(str: "PEER002"),
|
|
nickname: "Bob",
|
|
content: "Public hello from Bob",
|
|
timestamp: Date(),
|
|
messageID: "pub-001"
|
|
)
|
|
|
|
let found = await TestHelpers.waitUntil({
|
|
viewModel.publicMessages(for: .mesh).contains { $0.content == "Public hello from Bob" }
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(found)
|
|
}
|
|
}
|
|
|
|
// MARK: - Noise Payload Tests
|
|
|
|
struct ChatViewModelNoisePayloadTests {
|
|
|
|
@Test @MainActor
|
|
func didReceiveNoisePayload_privateMessageStoresMessageAndSendsDeliveryAck() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000003")
|
|
transport.simulateConnect(peerID, nickname: "Alice")
|
|
|
|
let payload = PrivateMessagePacket(messageID: "pm-noise-1", content: "Secret hello").encode()
|
|
#expect(payload != nil)
|
|
guard let payload else { return }
|
|
|
|
viewModel.didReceiveNoisePayload(
|
|
from: peerID,
|
|
type: .privateMessage,
|
|
payload: payload,
|
|
timestamp: Date()
|
|
)
|
|
|
|
let stored = await TestHelpers.waitUntil({
|
|
viewModel.privateChats[peerID]?.contains(where: { $0.id == "pm-noise-1" && $0.content == "Secret hello" }) == true
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
let acked = await TestHelpers.waitUntil({
|
|
transport.sentDeliveryAcks.contains { $0.messageID == "pm-noise-1" && $0.peerID == peerID }
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(stored)
|
|
#expect(acked)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didReceiveNoisePayload_deliveredUpdatesExistingPrivateMessageStatus() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000004")
|
|
transport.simulateConnect(peerID, nickname: "Bob")
|
|
|
|
let message = BitchatMessage(
|
|
id: "pm-delivered-1",
|
|
sender: viewModel.nickname,
|
|
content: "Waiting on ack",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: "Bob",
|
|
senderPeerID: viewModel.meshService.myPeerID,
|
|
mentions: nil,
|
|
deliveryStatus: .sent
|
|
)
|
|
viewModel.seedPrivateChat([message], for: peerID)
|
|
|
|
viewModel.didReceiveNoisePayload(
|
|
from: peerID,
|
|
type: .delivered,
|
|
payload: Data("pm-delivered-1".utf8),
|
|
timestamp: Date()
|
|
)
|
|
|
|
let delivered = await TestHelpers.waitUntil({
|
|
guard let status = viewModel.privateChats[peerID]?.first?.deliveryStatus else { return false }
|
|
if case .delivered(let name, _) = status {
|
|
return name == "Bob"
|
|
}
|
|
return false
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(delivered)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didReceiveNoisePayload_readReceiptUpdatesBeforePeerNicknameIsKnown() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "0000000000000005")
|
|
|
|
let message = BitchatMessage(
|
|
id: "pm-read-before-name",
|
|
sender: viewModel.nickname,
|
|
content: "Waiting on read receipt",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: "Peer",
|
|
senderPeerID: viewModel.meshService.myPeerID,
|
|
mentions: nil,
|
|
deliveryStatus: .sent
|
|
)
|
|
viewModel.seedPrivateChat([message], for: peerID)
|
|
|
|
viewModel.didReceiveNoisePayload(
|
|
from: peerID,
|
|
type: .readReceipt,
|
|
payload: Data("pm-read-before-name".utf8),
|
|
timestamp: Date()
|
|
)
|
|
|
|
let privateChatUpdated = await TestHelpers.waitUntil({
|
|
guard let status = viewModel.privateChats[peerID]?.first?.deliveryStatus else { return false }
|
|
if case .read = status {
|
|
return true
|
|
}
|
|
return false
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
let conversationStoreUpdated = await TestHelpers.waitUntil({
|
|
let messages = viewModel.conversations.conversationsByID[.directPeer(peerID)]?.messages ?? []
|
|
guard let status = messages.first?.deliveryStatus else { return false }
|
|
if case .read = status {
|
|
return true
|
|
}
|
|
return false
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(privateChatUpdated)
|
|
#expect(conversationStoreUpdated)
|
|
}
|
|
}
|
|
|
|
// MARK: - Formatting Tests
|
|
|
|
struct ChatViewModelFormattingTests {
|
|
|
|
@Test @MainActor
|
|
func formatMessageAsText_formatsSenderContentAndTimestamp() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let message = BitchatMessage(
|
|
id: "fmt-1",
|
|
sender: "Alice#a1b2",
|
|
content: "hello #mesh",
|
|
timestamp: Date(timeIntervalSince1970: 1_700_010_000),
|
|
isRelay: false,
|
|
senderPeerID: PeerID(str: "00000000000000b1")
|
|
)
|
|
|
|
let formatted = viewModel.formatMessageAsText(message, colorScheme: .light)
|
|
|
|
#expect(String(formatted.characters) == "<@Alice#a1b2> hello #mesh [\(message.formattedTimestamp)]")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func formatMessageAsText_longCashuFallsBackToPlain() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let cashu = "cashuA" + String(repeating: "a", count: 40)
|
|
let longContent = "hi @bob " + cashu + " " + String(repeating: "x", count: 4_100)
|
|
let message = BitchatMessage(
|
|
id: "fmt-long-cashu",
|
|
sender: "Alice#a1b2",
|
|
content: longContent,
|
|
timestamp: Date(timeIntervalSince1970: 1_700_010_123),
|
|
isRelay: false,
|
|
senderPeerID: PeerID(str: "00000000000000b3")
|
|
)
|
|
|
|
let formatted = viewModel.formatMessageAsText(message, colorScheme: .light)
|
|
|
|
#expect(String(formatted.characters) == "<@Alice#a1b2> \(longContent) [\(message.formattedTimestamp)]")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func formatMessageHeader_formatsSenderHeader() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let message = BitchatMessage(
|
|
id: "fmt-2",
|
|
sender: "Alice#a1b2",
|
|
content: "hello",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
senderPeerID: PeerID(str: "00000000000000b2")
|
|
)
|
|
|
|
let header = viewModel.formatMessageHeader(message, colorScheme: .dark)
|
|
|
|
#expect(String(header.characters) == "<@Alice#a1b2> ")
|
|
}
|
|
}
|
|
|
|
// MARK: - Verification Tests
|
|
|
|
struct ChatViewModelVerificationTests {
|
|
|
|
@Test @MainActor
|
|
func beginQRVerification_unknownNoiseKeyReturnsFalse() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let qr = VerificationService.VerificationQR(
|
|
v: 1,
|
|
noiseKeyHex: String(repeating: "a", count: 64),
|
|
signKeyHex: String(repeating: "b", count: 64),
|
|
npub: nil,
|
|
nickname: "Alice",
|
|
ts: 1_700_000_000,
|
|
nonceB64: "nonce",
|
|
sigHex: "sig"
|
|
)
|
|
|
|
#expect(!viewModel.beginQRVerification(with: qr))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func beginQRVerification_knownPeerTriggersHandshakeWhenSessionNotEstablished() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "00000000000000c1")
|
|
let noiseKey = Data(repeating: 0xAB, count: 32)
|
|
|
|
transport.updatePeerSnapshots([
|
|
TransportPeerSnapshot(
|
|
peerID: peerID,
|
|
nickname: "Alice",
|
|
isConnected: true,
|
|
noisePublicKey: noiseKey,
|
|
lastSeen: Date()
|
|
)
|
|
])
|
|
|
|
let bound = await TestHelpers.waitUntil({
|
|
viewModel.unifiedPeerService.peers.contains { $0.peerID == peerID }
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
#expect(bound)
|
|
|
|
let qr = VerificationService.VerificationQR(
|
|
v: 1,
|
|
noiseKeyHex: noiseKey.hexEncodedString(),
|
|
signKeyHex: String(repeating: "c", count: 64),
|
|
npub: nil,
|
|
nickname: "Alice",
|
|
ts: 1_700_000_000,
|
|
nonceB64: "nonce",
|
|
sigHex: "sig"
|
|
)
|
|
|
|
#expect(viewModel.beginQRVerification(with: qr))
|
|
#expect(transport.triggeredHandshakes == [peerID])
|
|
}
|
|
}
|
|
|
|
// MARK: - Rate Limiting Tests
|
|
|
|
struct ChatViewModelRateLimitingTests {
|
|
|
|
@Test @MainActor
|
|
func handlePublicMessage_rateLimitsBurstBySender() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let senderID = PeerID(str: "1122334455667788")
|
|
let now = Date()
|
|
|
|
for i in 0..<6 {
|
|
let message = BitchatMessage(
|
|
id: "rate-\(i)",
|
|
sender: "Spammer",
|
|
content: "rate-msg-\(i)",
|
|
timestamp: now,
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: false,
|
|
recipientNickname: nil,
|
|
senderPeerID: senderID,
|
|
mentions: nil
|
|
)
|
|
viewModel.handlePublicMessage(message)
|
|
}
|
|
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
|
|
let burstMessages = viewModel.messages.filter { $0.content.hasPrefix("rate-msg-") }
|
|
#expect(burstMessages.count == 5)
|
|
#expect(!burstMessages.contains { $0.content == "rate-msg-5" })
|
|
}
|
|
}
|
|
|
|
// MARK: - Public Conversation Tests
|
|
|
|
struct ChatViewModelPublicConversationTests {
|
|
|
|
@Test @MainActor
|
|
func bridgeAliasReplacementDoesNotContentDedupAwayAuthenticatedRadioRow() {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let content = "same bridge and radio payload"
|
|
let timestamp = Date()
|
|
let bridgeMessage = BitchatMessage(
|
|
id: "bridge-event-id",
|
|
sender: "remote#beef",
|
|
content: content,
|
|
timestamp: timestamp,
|
|
isRelay: false,
|
|
senderPeerID: PeerID(bridge: String(repeating: "a", count: 64)),
|
|
isBridged: true
|
|
)
|
|
viewModel.handlePublicMessage(bridgeMessage)
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
#expect(viewModel.publicConversationContainsMessage(withID: bridgeMessage.id, in: .mesh))
|
|
|
|
viewModel.removeBridgeInjectedPublicMessage(withID: bridgeMessage.id)
|
|
let radioMessage = BitchatMessage(
|
|
id: "radio-stable-id",
|
|
sender: "remote",
|
|
content: content,
|
|
timestamp: timestamp,
|
|
isRelay: false,
|
|
senderPeerID: PeerID(str: "1122334455667788")
|
|
)
|
|
viewModel.handlePublicMessage(radioMessage)
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
|
|
#expect(!viewModel.publicConversationContainsMessage(withID: bridgeMessage.id, in: .mesh))
|
|
#expect(viewModel.publicConversationContainsMessage(withID: radioMessage.id, in: .mesh))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func addPublicSystemMessage_persistsAcrossTimelineRefresh() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
viewModel.addPublicSystemMessage("system refresh test")
|
|
viewModel.refreshVisibleMessages(from: .mesh)
|
|
|
|
// The system message lives in the mesh conversation itself, so the
|
|
// derived `messages` view still surfaces it after a refresh.
|
|
#expect(viewModel.messages.last?.content == "system refresh test")
|
|
#expect(viewModel.publicMessages(for: .mesh).last?.content == "system refresh test")
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearCurrentPublicTimeline_clearsVisibleAndBackedMessages() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
viewModel.addPublicSystemMessage("system clear test")
|
|
#expect(!viewModel.messages.isEmpty)
|
|
|
|
viewModel.clearCurrentPublicTimeline()
|
|
viewModel.refreshVisibleMessages(from: .mesh)
|
|
|
|
#expect(viewModel.messages.isEmpty)
|
|
#expect(viewModel.publicMessages(for: .mesh).isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func queuedGeohashSystemMessages_drainOnce() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
viewModel.queueGeohashSystemMessage("first")
|
|
viewModel.queueGeohashSystemMessage("second")
|
|
|
|
#expect(viewModel.drainPendingGeohashSystemMessages() == ["first", "second"])
|
|
#expect(viewModel.drainPendingGeohashSystemMessages().isEmpty)
|
|
}
|
|
}
|
|
|
|
// MARK: - Peer Connection Tests
|
|
|
|
struct ChatViewModelPeerTests {
|
|
|
|
@Test @MainActor
|
|
func typedPeerLifecycleEvents_applyBeforeReturning() {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "1122334455667788")
|
|
let incoming = BitchatMessage(
|
|
id: "typed-peer-incoming",
|
|
sender: "Alice",
|
|
content: "Hello",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
viewModel.seedPrivateChat([incoming], for: peerID)
|
|
viewModel.sentReadReceipts.insert(incoming.id)
|
|
|
|
viewModel.didReceiveTransportEvent(.peerConnected(peerID))
|
|
|
|
#expect(viewModel.isConnected)
|
|
|
|
viewModel.didReceiveTransportEvent(.peerDisconnected(peerID))
|
|
|
|
#expect(!viewModel.sentReadReceipts.contains(incoming.id))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func typedPeerListDeliveryAndBluetoothEvents_applyBeforeReturning() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let stalePeer = PeerID(str: "00000000000000a2")
|
|
let deliveryPeer = PeerID(str: "0102030405060708")
|
|
let messageID = "typed-delivery-status"
|
|
let delivered = DeliveryStatus.delivered(
|
|
to: "Alice",
|
|
at: Date(timeIntervalSince1970: 1_234)
|
|
)
|
|
let outgoing = BitchatMessage(
|
|
id: messageID,
|
|
sender: viewModel.nickname,
|
|
content: "On the way",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Alice",
|
|
senderPeerID: transport.myPeerID,
|
|
deliveryStatus: .sent
|
|
)
|
|
viewModel.markPrivateChatUnread(stalePeer)
|
|
viewModel.seedPrivateChat([outgoing], for: deliveryPeer)
|
|
|
|
viewModel.didReceiveTransportEvent(.peerListUpdated([]))
|
|
#expect(!viewModel.unreadPrivateMessages.contains(stalePeer))
|
|
|
|
viewModel.didReceiveTransportEvent(
|
|
.messageDeliveryStatusUpdated(
|
|
messageID: messageID,
|
|
status: delivered
|
|
)
|
|
)
|
|
#expect(
|
|
viewModel.privateMessages(for: deliveryPeer).first?.deliveryStatus
|
|
== delivered
|
|
)
|
|
|
|
viewModel.didReceiveTransportEvent(.bluetoothStateUpdated(.poweredOff))
|
|
#expect(viewModel.bluetoothState == .poweredOff)
|
|
#expect(viewModel.showBluetoothAlert)
|
|
|
|
// Snapshot events belong to TransportPeerEventsDelegate and are
|
|
// intentionally ignored at this typed sink.
|
|
viewModel.didReceiveTransportEvent(.peerSnapshotsUpdated([]))
|
|
#expect(viewModel.bluetoothState == .poweredOff)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didConnectToPeer_notifiesDelegate() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "NEWPEER")
|
|
|
|
transport.simulateConnect(peerID, nickname: "NewUser")
|
|
|
|
#expect(transport.connectedPeers.contains(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didDisconnectFromPeer_notifiesDelegate() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "OLDPEER")
|
|
|
|
transport.simulateConnect(peerID, nickname: "OldUser")
|
|
transport.simulateDisconnect(peerID)
|
|
|
|
#expect(!transport.connectedPeers.contains(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func isPeerConnected_delegatesToTransport() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "TESTPEER")
|
|
|
|
// Not connected initially
|
|
#expect(!transport.isPeerConnected(peerID))
|
|
|
|
transport.connectedPeers.insert(peerID)
|
|
|
|
#expect(transport.isPeerConnected(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didUpdatePeerList_removesStaleUnreadPeerWithoutMessages() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let stalePeer = PeerID(str: "00000000000000a2")
|
|
viewModel.markPrivateChatUnread(stalePeer)
|
|
|
|
viewModel.didUpdatePeerList([])
|
|
|
|
let cleaned = await TestHelpers.waitUntil({
|
|
!viewModel.unreadPrivateMessages.contains(stalePeer)
|
|
}, timeout: TestConstants.defaultTimeout)
|
|
|
|
#expect(cleaned)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didUpdatePeerList_preservesStableUnreadPeerWhenMessagesExist() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let stablePeer = PeerID(str: String(repeating: "a", count: 64))
|
|
let message = BitchatMessage(
|
|
id: "stable-noise-1",
|
|
sender: "Alice",
|
|
content: "Offline hello",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: stablePeer,
|
|
mentions: nil
|
|
)
|
|
viewModel.seedPrivateChat([message], for: stablePeer)
|
|
viewModel.markPrivateChatUnread(stablePeer)
|
|
|
|
viewModel.didUpdatePeerList([])
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
#expect(viewModel.unreadPrivateMessages.contains(stablePeer))
|
|
}
|
|
}
|
|
|
|
// MARK: - Deduplication Integration Tests
|
|
//
|
|
// Note: Detailed deduplication logic is tested in MessageDeduplicationServiceTests.
|
|
// These tests verify that ChatViewModel has a deduplication service configured.
|
|
|
|
struct ChatViewModelDeduplicationTests {
|
|
|
|
@Test @MainActor
|
|
func deduplicationService_isConfigured() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
// Verify the deduplication service is available and functional
|
|
// by checking that we can record and query content
|
|
let testContent = "Test dedup content \(UUID().uuidString)"
|
|
let testDate = Date()
|
|
|
|
viewModel.deduplicationService.recordContent(testContent, timestamp: testDate)
|
|
|
|
let retrieved = viewModel.deduplicationService.contentTimestamp(for: testContent)
|
|
#expect(retrieved == testDate)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func deduplicationService_normalizedKey_consistent() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
let content = "Hello World"
|
|
let key1 = viewModel.deduplicationService.normalizedContentKey(content)
|
|
let key2 = viewModel.deduplicationService.normalizedContentKey(content)
|
|
|
|
#expect(key1 == key2)
|
|
}
|
|
}
|
|
|
|
// MARK: - Private Chat Tests
|
|
|
|
struct ChatViewModelPrivateChatTests {
|
|
|
|
@Test @MainActor
|
|
func sendPrivateMessage_delegatesToTransport() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let recipientID = PeerID(str: "RECIPIENT")
|
|
|
|
// Set up connected peer for routing
|
|
transport.connectedPeers.insert(recipientID)
|
|
transport.peerNicknames[recipientID] = "Recipient"
|
|
|
|
viewModel.sendPrivateMessage("Secret message", to: recipientID)
|
|
|
|
// The message routing depends on connection state and other factors
|
|
// At minimum, it should not crash
|
|
#expect(Bool(true)) // If we get here without crash, the test passes
|
|
}
|
|
}
|
|
|
|
// MARK: - Private Chat Selection Tests
|
|
|
|
struct ChatViewModelPrivateChatSelectionTests {
|
|
|
|
@Test @MainActor
|
|
func openMostRelevantPrivateChat_prefersUnreadMostRecent() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerA = PeerID(str: "PEER_A")
|
|
let peerB = PeerID(str: "PEER_B")
|
|
|
|
let older = Date().addingTimeInterval(-120)
|
|
let newer = Date().addingTimeInterval(-30)
|
|
|
|
viewModel.seedPrivateChat([
|
|
BitchatMessage(
|
|
id: "a-1",
|
|
sender: "A",
|
|
content: "Old",
|
|
timestamp: older,
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: peerA
|
|
)
|
|
], for: peerA)
|
|
viewModel.seedPrivateChat([
|
|
BitchatMessage(
|
|
id: "b-1",
|
|
sender: "B",
|
|
content: "New",
|
|
timestamp: newer,
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: peerB
|
|
)
|
|
], for: peerB)
|
|
viewModel.markPrivateChatUnread(peerA)
|
|
viewModel.markPrivateChatUnread(peerB)
|
|
|
|
viewModel.openMostRelevantPrivateChat()
|
|
|
|
#expect(viewModel.selectedPrivateChatPeer == peerB)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func openMostRelevantPrivateChat_fallsBackToMostRecentChat() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerA = PeerID(str: "PEER_A")
|
|
let peerB = PeerID(str: "PEER_B")
|
|
|
|
let older = Date().addingTimeInterval(-200)
|
|
let newer = Date().addingTimeInterval(-20)
|
|
|
|
viewModel.seedPrivateChat([
|
|
BitchatMessage(
|
|
id: "a-1",
|
|
sender: "A",
|
|
content: "Old",
|
|
timestamp: older,
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: peerA
|
|
)
|
|
], for: peerA)
|
|
viewModel.seedPrivateChat([
|
|
BitchatMessage(
|
|
id: "b-1",
|
|
sender: "B",
|
|
content: "New",
|
|
timestamp: newer,
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: peerB
|
|
)
|
|
], for: peerB)
|
|
|
|
viewModel.openMostRelevantPrivateChat()
|
|
|
|
#expect(viewModel.selectedPrivateChatPeer == peerB)
|
|
}
|
|
}
|
|
|
|
// MARK: - Bluetooth State Tests
|
|
|
|
struct ChatViewModelBluetoothTests {
|
|
|
|
@Test @MainActor
|
|
func didUpdateBluetoothState_poweredOn_noAlert() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
transport.simulateBluetoothStateChange(.poweredOn)
|
|
|
|
// Give time for async processing
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
#expect(!viewModel.showBluetoothAlert)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didUpdateBluetoothState_poweredOff_showsAlert() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
transport.simulateBluetoothStateChange(.poweredOff)
|
|
|
|
// Give time for async processing
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
#expect(viewModel.showBluetoothAlert)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func didUpdateBluetoothState_unauthorized_showsAlert() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
transport.simulateBluetoothStateChange(.unauthorized)
|
|
|
|
// Give time for async processing
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
#expect(viewModel.showBluetoothAlert)
|
|
}
|
|
}
|
|
|
|
// MARK: - Private Media Deletion Tests
|
|
|
|
struct ChatViewModelPrivateMediaDeletionTests {
|
|
|
|
@Test @MainActor
|
|
func deleteMediaMessageTombstonesIncomingButNotOutgoingStableMedia() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: String(repeating: "8", count: 64))
|
|
let incomingID = "media-\(String(repeating: "e", count: 32))"
|
|
let outgoingID = "media-\(String(repeating: "f", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: incomingID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "incoming.jpg"
|
|
),
|
|
privateMediaMessage(
|
|
id: outgoingID,
|
|
sender: viewModel.nickname,
|
|
senderPeerID: transport.myPeerID,
|
|
recipient: "Peer",
|
|
filename: "outgoing.jpg"
|
|
)
|
|
], for: peerID)
|
|
|
|
viewModel.deleteMediaMessage(messageID: outgoingID)
|
|
#expect(transport.deletedPrivateMediaMessageIDBatches.isEmpty)
|
|
#expect(viewModel.privateChats[peerID]?.map(\.id) == [incomingID])
|
|
|
|
viewModel.deleteMediaMessage(messageID: incomingID)
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[incomingID]]
|
|
)
|
|
#expect(
|
|
transport.deletedPrivateMediaRelativePaths
|
|
== [[incomingID: "images/incoming/incoming.jpg"]]
|
|
)
|
|
#expect((viewModel.privateChats[peerID] ?? []).isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func stableDeleteProtectsPathSharedWithLegacyBubble() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.persistDeletedPrivateMediaResult = false
|
|
let peerID = PeerID(str: String(repeating: "6", count: 64))
|
|
let stableID = "media-\(String(repeating: "5", count: 32))"
|
|
let legacyID = UUID().uuidString
|
|
let filename = "shared-migration.jpg"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: stableID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: filename
|
|
),
|
|
privateMediaMessage(
|
|
id: legacyID,
|
|
sender: "Old client",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: filename
|
|
)
|
|
], for: peerID)
|
|
|
|
viewModel.deleteMediaMessage(messageID: stableID)
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[stableID]]
|
|
)
|
|
#expect(transport.deletedPrivateMediaRelativePaths == [[:]])
|
|
#expect(
|
|
transport.protectedPrivateMediaRelativePaths == [[
|
|
"images/incoming/\(filename)"
|
|
]]
|
|
)
|
|
#expect(
|
|
viewModel.privateChats[peerID]?.map(\.id)
|
|
== [stableID, legacyID]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func legacyIncomingDeleteLeavesAmbiguousPayloadForQuota() throws {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: String(repeating: "3", count: 64))
|
|
let incoming = try FileManager.default.url(
|
|
for: .applicationSupportDirectory,
|
|
in: .userDomainMask,
|
|
appropriateFor: nil,
|
|
create: true
|
|
)
|
|
.appendingPathComponent(
|
|
"files/images/incoming",
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: incoming,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let payload = incoming.appendingPathComponent(
|
|
"legacy-delete-\(UUID().uuidString).jpg"
|
|
)
|
|
try Data([0x01]).write(to: payload)
|
|
defer { try? FileManager.default.removeItem(at: payload) }
|
|
let legacyID = UUID().uuidString
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: legacyID,
|
|
sender: "Old client",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: payload.lastPathComponent
|
|
)
|
|
], for: peerID)
|
|
|
|
viewModel.deleteMediaMessage(messageID: legacyID)
|
|
|
|
#expect(transport.deletedPrivateMediaMessageIDBatches.isEmpty)
|
|
#expect((viewModel.privateChats[peerID] ?? []).isEmpty)
|
|
#expect(FileManager.default.fileExists(atPath: payload.path))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatTombstonesIncomingAndCancelsOutgoingBeforeClear() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: String(repeating: "1", count: 64))
|
|
let incomingID = "media-\(String(repeating: "a", count: 32))"
|
|
let outgoingID = "media-\(String(repeating: "b", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: incomingID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "incoming.jpg"
|
|
),
|
|
privateMediaMessage(
|
|
id: outgoingID,
|
|
sender: viewModel.nickname,
|
|
senderPeerID: transport.myPeerID,
|
|
recipient: "Peer",
|
|
filename: "outgoing.jpg"
|
|
),
|
|
BitchatMessage(
|
|
id: "ordinary-message",
|
|
sender: "Peer",
|
|
content: "hello",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
], for: peerID)
|
|
viewModel.registerTransfer(
|
|
transferId: "outgoing-clear-transfer",
|
|
messageID: outgoingID
|
|
)
|
|
|
|
viewModel.clearPrivateChat(peerID)
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[incomingID]]
|
|
)
|
|
#expect(
|
|
transport.deletedPrivateMediaRelativePaths
|
|
== [[incomingID: "images/incoming/incoming.jpg"]]
|
|
)
|
|
#expect(
|
|
transport.cancelledTransfers == ["outgoing-clear-transfer"]
|
|
)
|
|
#expect(viewModel.messageIDToTransferId[outgoingID] == nil)
|
|
#expect(viewModel.privateChats[peerID]?.isEmpty == true)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatPreservesCapturedMessagesWhenTombstoneFails() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.persistDeletedPrivateMediaResult = false
|
|
let peerID = PeerID(str: String(repeating: "2", count: 64))
|
|
let incomingID = "media-\(String(repeating: "c", count: 32))"
|
|
let outgoingID = "media-\(String(repeating: "7", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: incomingID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "incoming.jpg"
|
|
),
|
|
privateMediaMessage(
|
|
id: outgoingID,
|
|
sender: viewModel.nickname,
|
|
senderPeerID: transport.myPeerID,
|
|
recipient: "Peer",
|
|
filename: "outgoing.jpg"
|
|
),
|
|
BitchatMessage(
|
|
id: "ordinary-message",
|
|
sender: "Peer",
|
|
content: "keep me on failure",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
], for: peerID)
|
|
viewModel.registerTransfer(
|
|
transferId: "failed-clear-outgoing",
|
|
messageID: outgoingID
|
|
)
|
|
|
|
viewModel.clearPrivateChat(peerID)
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[incomingID]]
|
|
)
|
|
#expect(
|
|
viewModel.privateChats[peerID]?.map(\.id)
|
|
== [incomingID, outgoingID, "ordinary-message"]
|
|
)
|
|
#expect(transport.cancelledTransfers == ["failed-clear-outgoing"])
|
|
#expect(viewModel.messageIDToTransferId[outgoingID] == nil)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearFailurePreservesSameNameIncomingPayload() throws {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.persistDeletedPrivateMediaResult = false
|
|
let peerID = PeerID(str: String(repeating: "7", count: 64))
|
|
let incomingID = "media-\(String(repeating: "8", count: 32))"
|
|
let outgoingID = "media-\(String(repeating: "9", count: 32))"
|
|
let filename = "clear-collision-\(UUID().uuidString).jpg"
|
|
let filesDirectory = try FileManager.default.url(
|
|
for: .applicationSupportDirectory,
|
|
in: .userDomainMask,
|
|
appropriateFor: nil,
|
|
create: true
|
|
)
|
|
.appendingPathComponent("files/images", isDirectory: true)
|
|
let incomingDirectory = filesDirectory.appendingPathComponent(
|
|
"incoming",
|
|
isDirectory: true
|
|
)
|
|
let outgoingDirectory = filesDirectory.appendingPathComponent(
|
|
"outgoing",
|
|
isDirectory: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: incomingDirectory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
try FileManager.default.createDirectory(
|
|
at: outgoingDirectory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let incomingURL = incomingDirectory.appendingPathComponent(filename)
|
|
let outgoingURL = outgoingDirectory.appendingPathComponent(filename)
|
|
try Data("incoming".utf8).write(to: incomingURL, options: .atomic)
|
|
try Data("outgoing".utf8).write(to: outgoingURL, options: .atomic)
|
|
defer {
|
|
try? FileManager.default.removeItem(at: incomingURL)
|
|
try? FileManager.default.removeItem(at: outgoingURL)
|
|
}
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: incomingID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: filename
|
|
),
|
|
privateMediaMessage(
|
|
id: outgoingID,
|
|
sender: viewModel.nickname,
|
|
senderPeerID: transport.myPeerID,
|
|
recipient: "Peer",
|
|
filename: filename
|
|
)
|
|
], for: peerID)
|
|
|
|
viewModel.clearPrivateChat(peerID)
|
|
|
|
#expect(FileManager.default.fileExists(atPath: incomingURL.path))
|
|
#expect(FileManager.default.fileExists(atPath: outgoingURL.path))
|
|
#expect(
|
|
transport.deletedPrivateMediaRelativePaths
|
|
== [[incomingID: "images/incoming/\(filename)"]]
|
|
)
|
|
#expect(
|
|
viewModel.privateChats[peerID]?.map(\.id)
|
|
== [incomingID, outgoingID]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatPreservesArrivalDuringTombstoneIO() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.deferDeletedPrivateMediaPersistence = true
|
|
let peerID = PeerID(str: String(repeating: "3", count: 64))
|
|
let incomingID = "media-\(String(repeating: "d", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: incomingID,
|
|
sender: "Peer",
|
|
senderPeerID: peerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "incoming.jpg"
|
|
),
|
|
BitchatMessage(
|
|
id: "captured-text",
|
|
sender: "Peer",
|
|
content: "old",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
], for: peerID)
|
|
|
|
viewModel.clearPrivateChat(peerID)
|
|
let arrival = BitchatMessage(
|
|
id: "concurrent-arrival",
|
|
sender: "Peer",
|
|
content: "new",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
#expect(viewModel.appendPrivateMessage(arrival, to: peerID))
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect(
|
|
viewModel.privateChats[peerID]?.map(\.id)
|
|
== ["concurrent-arrival"]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatPreservesActiveLiveVoiceAssembly() throws {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let peerID = PeerID(str: String(repeating: "7", count: 64))
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
let burstID = Data(
|
|
repeating: 0xE1,
|
|
count: VoiceBurstPacket.burstIDSize
|
|
)
|
|
let start = try #require(VoiceBurstPacket(
|
|
burstID: burstID,
|
|
seq: 0,
|
|
kind: .start(codec: .aacLC16kMono)
|
|
))
|
|
let cancel = try #require(VoiceBurstPacket(
|
|
burstID: burstID,
|
|
seq: 1,
|
|
kind: .canceled
|
|
))
|
|
let coordinator = viewModel.liveVoiceCoordinator
|
|
defer {
|
|
coordinator.handleVoiceFramePayload(
|
|
from: peerID,
|
|
payload: cancel.encode(),
|
|
timestamp: Date()
|
|
)
|
|
}
|
|
coordinator.handleVoiceFramePayload(
|
|
from: peerID,
|
|
payload: start.encode(),
|
|
timestamp: Date()
|
|
)
|
|
let liveMessage = try #require(
|
|
viewModel.privateChats[peerID]?.first
|
|
)
|
|
#expect(coordinator.isLiveVoiceMessage(liveMessage))
|
|
let ordinary = BitchatMessage(
|
|
id: "clear-around-live-voice",
|
|
sender: "Peer",
|
|
content: "old text",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: peerID
|
|
)
|
|
#expect(viewModel.appendPrivateMessage(ordinary, to: peerID))
|
|
|
|
viewModel.clearPrivateChat(peerID)
|
|
|
|
#expect(transport.deletedPrivateMediaMessageIDBatches.isEmpty)
|
|
#expect(
|
|
viewModel.privateChats[peerID]?.map(\.id)
|
|
== [liveMessage.id]
|
|
)
|
|
#expect(coordinator.isLiveVoiceMessage(liveMessage))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func overlappingClearsTombstoneTheLastMirroredStableAlias() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.deferDeletedPrivateMediaPersistence = true
|
|
let firstPeerID = PeerID(str: String(repeating: "b", count: 64))
|
|
let secondPeerID = PeerID(str: String(repeating: "c", count: 64))
|
|
let sharedID = "media-\(String(repeating: "1", count: 32))"
|
|
let firstUniqueID = "media-\(String(repeating: "2", count: 32))"
|
|
let secondUniqueID = "media-\(String(repeating: "3", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: sharedID,
|
|
sender: "Peer",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "shared.jpg"
|
|
),
|
|
privateMediaMessage(
|
|
id: firstUniqueID,
|
|
sender: "Peer",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "first.jpg"
|
|
)
|
|
], for: firstPeerID)
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: sharedID,
|
|
sender: "Peer",
|
|
senderPeerID: secondPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "shared.jpg"
|
|
),
|
|
privateMediaMessage(
|
|
id: secondUniqueID,
|
|
sender: "Peer",
|
|
senderPeerID: secondPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "second.jpg"
|
|
)
|
|
], for: secondPeerID)
|
|
|
|
viewModel.clearPrivateChat(firstPeerID)
|
|
viewModel.clearPrivateChat(secondPeerID)
|
|
let queuedArrival = BitchatMessage(
|
|
id: "arrival-after-queued-clear",
|
|
sender: "Peer",
|
|
content: "new",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: secondPeerID
|
|
)
|
|
#expect(viewModel.appendPrivateMessage(
|
|
queuedArrival,
|
|
to: secondPeerID
|
|
))
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches
|
|
== [[firstUniqueID]]
|
|
)
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [
|
|
[firstUniqueID],
|
|
[secondUniqueID, sharedID].sorted()
|
|
]
|
|
)
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect((viewModel.privateChats[firstPeerID] ?? []).isEmpty)
|
|
#expect(
|
|
viewModel.privateChats[secondPeerID]?.map(\.id)
|
|
== ["arrival-after-queued-clear"]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearFollowsCapturedRowsAcrossPeerIdentityMigration() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.deferDeletedPrivateMediaPersistence = true
|
|
let sourcePeerID = PeerID(str: String(repeating: "d", count: 64))
|
|
let destinationPeerID = PeerID(str: String(repeating: "e", count: 64))
|
|
let thirdPeerID = PeerID(str: String(repeating: "f", count: 64))
|
|
let stableID = "media-\(String(repeating: "4", count: 32))"
|
|
viewModel.selectedPrivateChatPeer = sourcePeerID
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: stableID,
|
|
sender: "Peer",
|
|
senderPeerID: sourcePeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "migrated.jpg"
|
|
),
|
|
BitchatMessage(
|
|
id: "captured-before-migration",
|
|
sender: "Peer",
|
|
content: "old",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: sourcePeerID
|
|
)
|
|
], for: sourcePeerID)
|
|
|
|
viewModel.clearPrivateChat(sourcePeerID)
|
|
viewModel.migratePrivateChat(
|
|
from: sourcePeerID,
|
|
to: destinationPeerID
|
|
)
|
|
viewModel.selectedPrivateChatPeer = thirdPeerID
|
|
let arrival = BitchatMessage(
|
|
id: "arrival-after-migration",
|
|
sender: "Peer",
|
|
content: "new",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: destinationPeerID
|
|
)
|
|
#expect(viewModel.appendPrivateMessage(
|
|
arrival,
|
|
to: destinationPeerID
|
|
))
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect(
|
|
viewModel.privateChats[destinationPeerID]?.map(\.id)
|
|
== ["arrival-after-migration"]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearFollowsMigrationWhenOldSourceIsRecreated() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.deferDeletedPrivateMediaPersistence = true
|
|
let sourcePeerID = PeerID(str: String(repeating: "1", count: 64))
|
|
let destinationPeerID = PeerID(str: String(repeating: "2", count: 64))
|
|
let stableID = "media-\(String(repeating: "6", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: stableID,
|
|
sender: "Peer",
|
|
senderPeerID: sourcePeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "migrated-recreated.jpg"
|
|
),
|
|
BitchatMessage(
|
|
id: "captured-before-recreation",
|
|
sender: "Peer",
|
|
content: "old",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: sourcePeerID
|
|
)
|
|
], for: sourcePeerID)
|
|
|
|
viewModel.clearPrivateChat(sourcePeerID)
|
|
viewModel.migratePrivateChat(
|
|
from: sourcePeerID,
|
|
to: destinationPeerID
|
|
)
|
|
let recreatedArrival = BitchatMessage(
|
|
id: "arrival-recreating-source",
|
|
sender: "Peer",
|
|
content: "new",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: viewModel.nickname,
|
|
senderPeerID: sourcePeerID
|
|
)
|
|
#expect(viewModel.appendPrivateMessage(
|
|
recreatedArrival,
|
|
to: sourcePeerID
|
|
))
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect(
|
|
(viewModel.privateChats[destinationPeerID] ?? []).isEmpty
|
|
)
|
|
#expect(
|
|
viewModel.privateChats[sourcePeerID]?.map(\.id)
|
|
== ["arrival-recreating-source"]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatKeepsMediaReferencedByAnotherConversation() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let firstPeerID = PeerID(str: String(repeating: "4", count: 64))
|
|
let aliasPeerID = PeerID(str: String(repeating: "5", count: 64))
|
|
let messageID = "media-\(String(repeating: "6", count: 32))"
|
|
let message = privateMediaMessage(
|
|
id: messageID,
|
|
sender: "Peer",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "mirrored.jpg"
|
|
)
|
|
viewModel.seedPrivateChat([message], for: firstPeerID)
|
|
viewModel.seedPrivateChat([message], for: aliasPeerID)
|
|
|
|
viewModel.clearPrivateChat(firstPeerID)
|
|
|
|
#expect(transport.deletedPrivateMediaMessageIDBatches.isEmpty)
|
|
#expect(viewModel.privateChats[firstPeerID]?.isEmpty == true)
|
|
#expect(
|
|
viewModel.privateChats[aliasPeerID]?.map(\.id) == [messageID]
|
|
)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func clearPrivateChatLeavesAmbiguousLegacyFileForQuotaCleanup()
|
|
throws {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
let firstPeerID = PeerID(str: String(repeating: "9", count: 64))
|
|
let aliasPeerID = PeerID(str: String(repeating: "a", count: 64))
|
|
let incomingDirectory = try FileManager.default.url(
|
|
for: .applicationSupportDirectory,
|
|
in: .userDomainMask,
|
|
appropriateFor: nil,
|
|
create: true
|
|
)
|
|
.appendingPathComponent("files/images/incoming", isDirectory: true)
|
|
try FileManager.default.createDirectory(
|
|
at: incomingDirectory,
|
|
withIntermediateDirectories: true
|
|
)
|
|
let fileURL = incomingDirectory.appendingPathComponent(
|
|
"legacy-clear-\(UUID().uuidString).jpg"
|
|
)
|
|
try Data("legacy-image".utf8).write(to: fileURL, options: .atomic)
|
|
defer { try? FileManager.default.removeItem(at: fileURL) }
|
|
let message = privateMediaMessage(
|
|
id: UUID().uuidString,
|
|
sender: "Old client",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: fileURL.lastPathComponent
|
|
)
|
|
viewModel.seedPrivateChat([message], for: firstPeerID)
|
|
viewModel.seedPrivateChat([message], for: aliasPeerID)
|
|
|
|
viewModel.clearPrivateChat(firstPeerID)
|
|
|
|
#expect(transport.deletedPrivateMediaMessageIDBatches.isEmpty)
|
|
#expect(FileManager.default.fileExists(atPath: fileURL.path))
|
|
#expect(viewModel.privateChats[aliasPeerID]?.map(\.id) == [message.id])
|
|
|
|
viewModel.clearPrivateChat(aliasPeerID)
|
|
|
|
#expect(FileManager.default.fileExists(atPath: fileURL.path))
|
|
#expect((viewModel.privateChats[aliasPeerID] ?? []).isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func panicInvalidatesActiveAndQueuedPrivateChatClears() {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
transport.deferDeletedPrivateMediaPersistence = true
|
|
let firstPeerID = PeerID(str: String(repeating: "4", count: 64))
|
|
let secondPeerID = PeerID(str: String(repeating: "5", count: 64))
|
|
let firstID = "media-\(String(repeating: "6", count: 32))"
|
|
let secondID = "media-\(String(repeating: "7", count: 32))"
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: firstID,
|
|
sender: "First",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "first-pre-panic.jpg"
|
|
)
|
|
], for: firstPeerID)
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: secondID,
|
|
sender: "Second",
|
|
senderPeerID: secondPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "second-pre-panic.jpg"
|
|
)
|
|
], for: secondPeerID)
|
|
|
|
viewModel.clearPrivateChat(firstPeerID)
|
|
viewModel.clearPrivateChat(secondPeerID)
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[firstID]]
|
|
)
|
|
|
|
_ = viewModel.panicClearAllData(restartServices: false)
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: firstID,
|
|
sender: "First",
|
|
senderPeerID: firstPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "first-post-panic.jpg"
|
|
)
|
|
], for: firstPeerID)
|
|
viewModel.seedPrivateChat([
|
|
privateMediaMessage(
|
|
id: secondID,
|
|
sender: "Second",
|
|
senderPeerID: secondPeerID,
|
|
recipient: viewModel.nickname,
|
|
filename: "second-post-panic.jpg"
|
|
)
|
|
], for: secondPeerID)
|
|
|
|
transport.resolveNextDeletedPrivateMediaPersistence(true)
|
|
|
|
#expect(
|
|
transport.deletedPrivateMediaMessageIDBatches == [[firstID]]
|
|
)
|
|
#expect(viewModel.privateChats[firstPeerID]?.map(\.id) == [firstID])
|
|
#expect(viewModel.privateChats[secondPeerID]?.map(\.id) == [secondID])
|
|
}
|
|
|
|
private func privateMediaMessage(
|
|
id: String,
|
|
sender: String,
|
|
senderPeerID: PeerID,
|
|
recipient: String,
|
|
filename: String
|
|
) -> BitchatMessage {
|
|
BitchatMessage(
|
|
id: id,
|
|
sender: sender,
|
|
content: "\(MimeType.Category.image.messagePrefix)\(filename)",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: recipient,
|
|
senderPeerID: senderPeerID
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - Panic Clear Tests
|
|
|
|
struct ChatViewModelPanicTests {
|
|
|
|
@Test @MainActor
|
|
func panicClearAllData_finishesMediaWipeBeforeReturning() {
|
|
var wipeFinished = false
|
|
let (viewModel, _) = makeTestableViewModel(panicMediaWipe: {
|
|
wipeFinished = true
|
|
})
|
|
|
|
viewModel.panicClearAllData()
|
|
|
|
#expect(wipeFinished)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func panicClearAllData_stopsNetworkBeforeWipeAndRestartsAfterCommit() {
|
|
var events: [String] = []
|
|
let lifecycle = PanicNetworkLifecycle(
|
|
stop: { events.append("stop") },
|
|
restart: { events.append("restart") }
|
|
)
|
|
let (viewModel, _) = makeTestableViewModel(
|
|
panicMediaWipe: { events.append("wipe") },
|
|
panicNetworkLifecycle: lifecycle
|
|
)
|
|
|
|
let completed = viewModel.panicClearAllData()
|
|
|
|
#expect(completed)
|
|
#expect(events == ["stop", "wipe", "restart"])
|
|
#expect(viewModel.networkActivationAllowed)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func panicKeychainFailureKeepsRecoveryPendingAndServicesStopped() {
|
|
let keychain = MockKeychain()
|
|
keychain.simulatedDeleteAllResult = false
|
|
var events: [String] = []
|
|
let operations = PanicRecoveryOperations(
|
|
isPending: { false },
|
|
begin: {
|
|
events.append("begin")
|
|
return PanicRecoveryIntent(
|
|
fileMarkerEstablished: true,
|
|
externalMarkerEstablished: false
|
|
)
|
|
},
|
|
wipeMedia: { _ in events.append("wipe") },
|
|
complete: { events.append("complete") }
|
|
)
|
|
let lifecycle = PanicNetworkLifecycle(
|
|
stop: { events.append("stop") },
|
|
restart: { events.append("restart") }
|
|
)
|
|
let (viewModel, transport) = makeTestableViewModel(
|
|
keychain: keychain,
|
|
panicRecoveryOperations: operations,
|
|
panicNetworkLifecycle: lifecycle
|
|
)
|
|
let startsBeforePanic = transport.startServicesCallCount
|
|
|
|
let completed = viewModel.panicClearAllData()
|
|
|
|
#expect(!completed)
|
|
#expect(events == ["stop", "begin", "wipe"])
|
|
#expect(keychain.deleteAllCallCount == 1)
|
|
#expect(transport.startServicesCallCount == startsBeforePanic)
|
|
#expect(!viewModel.networkActivationAllowed)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func pendingPanicRecoveryCompletesBeforeTransportBootstrap() {
|
|
var events: [String] = []
|
|
let operations = PanicRecoveryOperations(
|
|
isPending: {
|
|
events.append("read")
|
|
return true
|
|
},
|
|
begin: {
|
|
events.append("begin")
|
|
return PanicRecoveryIntent(
|
|
fileMarkerEstablished: true,
|
|
externalMarkerEstablished: false
|
|
)
|
|
},
|
|
wipeMedia: { _ in events.append("wipe") },
|
|
complete: { events.append("complete") }
|
|
)
|
|
|
|
let (viewModel, transport) = makeTestableViewModel(
|
|
panicRecoveryOperations: operations
|
|
)
|
|
|
|
#expect(events == ["read", "begin", "wipe", "complete"])
|
|
#expect(transport.emergencyDisconnectCallCount == 1)
|
|
#expect(transport.startServicesCallCount == 1)
|
|
#expect(viewModel.networkActivationAllowed)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func failedStartupRecoveryLeavesTransportAndNetworkBlocked() {
|
|
enum WipeFailure: Error { case failed }
|
|
var completedMarker = false
|
|
let operations = PanicRecoveryOperations(
|
|
isPending: { true },
|
|
begin: {
|
|
PanicRecoveryIntent(
|
|
fileMarkerEstablished: true,
|
|
externalMarkerEstablished: false
|
|
)
|
|
},
|
|
wipeMedia: { _ in throw WipeFailure.failed },
|
|
complete: { completedMarker = true }
|
|
)
|
|
|
|
let (viewModel, transport) = makeTestableViewModel(
|
|
panicRecoveryOperations: operations
|
|
)
|
|
|
|
#expect(!completedMarker)
|
|
#expect(transport.emergencyDisconnectCallCount == 1)
|
|
#expect(transport.startServicesCallCount == 0)
|
|
#expect(!viewModel.networkActivationAllowed)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func failedStartupKeychainRecoveryLeavesIntentAndTransportBlocked() {
|
|
let keychain = MockKeychain()
|
|
keychain.simulatedDeleteAllResult = false
|
|
var events: [String] = []
|
|
let operations = PanicRecoveryOperations(
|
|
isPending: { true },
|
|
begin: {
|
|
events.append("begin")
|
|
return PanicRecoveryIntent(
|
|
fileMarkerEstablished: true,
|
|
externalMarkerEstablished: true
|
|
)
|
|
},
|
|
wipeMedia: { _ in events.append("wipe") },
|
|
complete: { events.append("complete") }
|
|
)
|
|
|
|
let (viewModel, transport) = makeTestableViewModel(
|
|
keychain: keychain,
|
|
panicRecoveryOperations: operations
|
|
)
|
|
|
|
#expect(events == ["begin", "wipe"])
|
|
#expect(keychain.deleteAllCallCount == 1)
|
|
#expect(transport.emergencyDisconnectCallCount == 1)
|
|
#expect(transport.startServicesCallCount == 0)
|
|
#expect(!viewModel.networkActivationAllowed)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func panicClearAllData_delegatesToTransport() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
|
|
// Set up some state
|
|
transport.connectedPeers.insert(PeerID(str: "PEER1"))
|
|
viewModel.seedPublicMessages([
|
|
BitchatMessage(
|
|
id: "panic-1",
|
|
sender: "Tester",
|
|
content: "Before",
|
|
timestamp: Date(),
|
|
isRelay: false
|
|
)
|
|
])
|
|
viewModel.seedPrivateChat([
|
|
BitchatMessage(
|
|
id: "pm-1",
|
|
sender: "Peer",
|
|
content: "Secret",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: PeerID(str: "PEER1")
|
|
)
|
|
], for: PeerID(str: "PEER1"))
|
|
viewModel.markPrivateChatUnread(PeerID(str: "PEER1"))
|
|
|
|
viewModel.panicClearAllData()
|
|
|
|
// After panic, emergency disconnect should be called
|
|
#expect(transport.emergencyDisconnectCallCount == 1)
|
|
#expect(viewModel.messages.isEmpty)
|
|
#expect(viewModel.privateChats.isEmpty)
|
|
#expect(viewModel.unreadPrivateMessages.isEmpty)
|
|
#expect(viewModel.selectedPrivateChatPeer == nil)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func panicClearAllData_resetsLiveGeohashAndNostrState() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruy"
|
|
let channel = GeohashChannel(level: .city, geohash: geohash)
|
|
let identity = try NostrIdentity.generate()
|
|
let pubkey = String(repeating: "ab", count: 32)
|
|
let peerID = PeerID(nostr: pubkey)
|
|
|
|
viewModel.activeChannel = .location(channel)
|
|
viewModel.setGeoChatSubscriptionID("geo-\(geohash)")
|
|
viewModel.setGeoDmSubscriptionID("geo-dm-\(geohash)")
|
|
viewModel.addGeoSamplingSub("geo-sample-\(geohash)", forGeohash: geohash)
|
|
viewModel.cachedGeohashIdentity = (geohash, identity)
|
|
viewModel.registerNostrKeyMapping(pubkey, for: peerID)
|
|
viewModel.currentGeohash = geohash
|
|
viewModel.geoNicknames = [pubkey: "alice"]
|
|
viewModel.teleportedGeo = [pubkey]
|
|
|
|
viewModel.panicClearAllData()
|
|
|
|
#expect(viewModel.activeChannel == .mesh)
|
|
#expect(viewModel.geoSubscriptionID == nil)
|
|
#expect(viewModel.geoDmSubscriptionID == nil)
|
|
#expect(viewModel.geoSamplingSubs.isEmpty)
|
|
#expect(viewModel.cachedGeohashIdentity == nil)
|
|
#expect(viewModel.nostrKeyMapping.isEmpty)
|
|
#expect(viewModel.currentGeohash == nil)
|
|
#expect(viewModel.geoNicknames.isEmpty)
|
|
#expect(viewModel.teleportedGeo.isEmpty)
|
|
}
|
|
}
|
|
|
|
// MARK: - Service Lifecycle Tests
|
|
|
|
struct ChatViewModelLifecycleTests {
|
|
|
|
@Test @MainActor
|
|
func startServices_calledOnInit() async {
|
|
let (_, transport) = makeTestableViewModel()
|
|
|
|
#expect(transport.startServicesCallCount == 1)
|
|
}
|
|
}
|