mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-24 23:45:18 +00:00
460 lines
17 KiB
Swift
460 lines
17 KiB
Swift
//
|
|
// ChatViewModelExtensionsTests.swift
|
|
// bitchatTests
|
|
//
|
|
// Tests for ChatViewModel extensions (PrivateChat, Nostr, Tor).
|
|
//
|
|
|
|
import Testing
|
|
import Foundation
|
|
import Combine
|
|
@testable import bitchat
|
|
|
|
// MARK: - Test Helpers
|
|
|
|
@MainActor
|
|
private func makeTestableViewModel() -> (viewModel: ChatViewModel, transport: MockTransport) {
|
|
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
|
|
)
|
|
|
|
return (viewModel, transport)
|
|
}
|
|
|
|
// MARK: - Private Chat Extension Tests
|
|
|
|
struct ChatViewModelPrivateChatExtensionTests {
|
|
|
|
@Test @MainActor
|
|
func sendPrivateMessage_mesh_storesAndSends() async {
|
|
let (viewModel, transport) = makeTestableViewModel()
|
|
// Use valid hex string for PeerID (32 bytes = 64 hex chars for Noise key usually, or just valid hex)
|
|
let validHex = "0102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f10"
|
|
let peerID = PeerID(str: validHex)
|
|
|
|
// Simulate connection
|
|
transport.connectedPeers.insert(peerID)
|
|
transport.peerNicknames[peerID] = "MeshUser"
|
|
|
|
viewModel.sendPrivateMessage("Hello Mesh", to: peerID)
|
|
|
|
// Verify transport was called
|
|
// Note: MockTransport stores sent messages
|
|
// Since sendPrivateMessage delegates to MessageRouter which delegates to Transport...
|
|
// We need to ensure MessageRouter is using our MockTransport.
|
|
// ChatViewModel init sets up MessageRouter with the passed transport.
|
|
|
|
// Wait for async processing
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
|
|
// Verify message stored locally
|
|
#expect(viewModel.privateChats[peerID]?.count == 1)
|
|
#expect(viewModel.privateChats[peerID]?.first?.content == "Hello Mesh")
|
|
|
|
// Verify message sent to transport (MockTransport captures sendPrivateMessage)
|
|
// MockTransport.sendPrivateMessage is what MessageRouter calls for connected peers
|
|
// Check MockTransport implementation... it might need update or verification
|
|
}
|
|
|
|
@Test @MainActor
|
|
func sendPrivateMessage_unreachable_setsFailedStatus() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let validHex = "0102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f10"
|
|
let peerID = PeerID(str: validHex)
|
|
|
|
viewModel.sendPrivateMessage("Hello", to: peerID)
|
|
|
|
#expect(viewModel.privateChats[peerID]?.count == 1)
|
|
let status = viewModel.privateChats[peerID]?.last?.deliveryStatus
|
|
#expect({
|
|
if case .failed = status { return true }
|
|
return false
|
|
}())
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handlePrivateMessage_storesMessage() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "SENDER_001")
|
|
|
|
let message = BitchatMessage(
|
|
id: "msg-1",
|
|
sender: "Sender",
|
|
content: "Private Content",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
originalSender: nil,
|
|
isPrivate: true,
|
|
recipientNickname: "Me",
|
|
senderPeerID: peerID
|
|
)
|
|
|
|
// Simulate receiving a private message via the handlePrivateMessage extension method
|
|
viewModel.handlePrivateMessage(message)
|
|
|
|
// Verify stored
|
|
#expect(viewModel.privateChats[peerID]?.count == 1)
|
|
#expect(viewModel.privateChats[peerID]?.first?.content == "Private Content")
|
|
|
|
// Verify notification trigger (unread count should increase if not viewing)
|
|
#expect(viewModel.unreadPrivateMessages.contains(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handlePrivateMessage_deduplicates() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "SENDER_001")
|
|
|
|
let message = BitchatMessage(
|
|
id: "msg-1",
|
|
sender: "Sender",
|
|
content: "Content",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
senderPeerID: peerID
|
|
)
|
|
|
|
viewModel.handlePrivateMessage(message)
|
|
viewModel.handlePrivateMessage(message) // Duplicate
|
|
|
|
#expect(viewModel.privateChats[peerID]?.count == 1)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handlePrivateMessage_sendsReadReceipt_whenViewing() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let peerID = PeerID(str: "SENDER_001")
|
|
|
|
// Set as currently viewing
|
|
viewModel.selectedPrivateChatPeer = peerID
|
|
|
|
let message = BitchatMessage(
|
|
id: "msg-1",
|
|
sender: "Sender",
|
|
content: "Content",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
senderPeerID: peerID
|
|
)
|
|
|
|
viewModel.handlePrivateMessage(message)
|
|
|
|
// Should NOT be marked unread
|
|
#expect(!viewModel.unreadPrivateMessages.contains(peerID))
|
|
}
|
|
|
|
@Test @MainActor
|
|
func migratePrivateChats_consolidatesHistory_onFingerprintMatch() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let oldPeerID = PeerID(str: "OLD_PEER")
|
|
let newPeerID = PeerID(str: "NEW_PEER")
|
|
let fingerprint = "fp_123"
|
|
|
|
// Setup old chat
|
|
let oldMessage = BitchatMessage(
|
|
id: "msg-old",
|
|
sender: "User",
|
|
content: "Old message",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
senderPeerID: oldPeerID
|
|
)
|
|
viewModel.privateChats[oldPeerID] = [oldMessage]
|
|
viewModel.peerIDToPublicKeyFingerprint[oldPeerID] = fingerprint
|
|
|
|
// Setup new peer fingerprint
|
|
viewModel.peerIDToPublicKeyFingerprint[newPeerID] = fingerprint
|
|
|
|
// Trigger migration
|
|
viewModel.migratePrivateChatsIfNeeded(for: newPeerID, senderNickname: "User")
|
|
|
|
// Verify migration
|
|
#expect(viewModel.privateChats[newPeerID]?.count == 1)
|
|
#expect(viewModel.privateChats[newPeerID]?.first?.content == "Old message")
|
|
#expect(viewModel.privateChats[oldPeerID] == nil) // Old chat removed
|
|
}
|
|
|
|
@Test @MainActor
|
|
func isMessageBlocked_filtersBlockedUsers() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let blockedPeerID = PeerID(str: "BLOCKED_PEER")
|
|
|
|
// Block the peer
|
|
// MockIdentityManager stores state based on fingerprint
|
|
// We need to map peerID to a fingerprint
|
|
viewModel.peerIDToPublicKeyFingerprint[blockedPeerID] = "fp_blocked"
|
|
viewModel.identityManager.setBlocked("fp_blocked", isBlocked: true)
|
|
|
|
// Also ensure UnifiedPeerService can resolve the fingerprint.
|
|
// UnifiedPeerService uses its own cache or delegates to meshService/Peer list.
|
|
// Since we are mocking, we can't easily inject into UnifiedPeerService's internal cache.
|
|
// However, ChatViewModel's isMessageBlocked uses:
|
|
// 1. isPeerBlocked(peerID) -> unifiedPeerService.isBlocked(peerID) -> getFingerprint -> identityManager.isBlocked
|
|
|
|
// We need UnifiedPeerService.getFingerprint(for: blockedPeerID) to return "fp_blocked"
|
|
// UnifiedPeerService tries: cache -> meshService -> getPeer
|
|
|
|
// Option 1: Mock the transport (meshService) to return the fingerprint
|
|
// (viewModel.transport is MockTransport, but UnifiedPeerService holds a reference to it)
|
|
// Check if MockTransport has `getFingerprint`
|
|
|
|
// If not, we might need to rely on the fallback: ChatViewModel.isMessageBlocked also checks Nostr blocks.
|
|
|
|
// Let's assume MockTransport needs `getFingerprint` implementation or update it.
|
|
// For now, let's try to verify if `MockTransport` supports `getFingerprint`.
|
|
|
|
// Actually, let's just use the Nostr block path which is simpler and also tested here.
|
|
// "Check geohash (Nostr) blocks using mapping to full pubkey"
|
|
|
|
let hexPubkey = "0000000000000000000000000000000000000000000000000000000000000001"
|
|
viewModel.nostrKeyMapping[blockedPeerID] = hexPubkey
|
|
viewModel.identityManager.setNostrBlocked(hexPubkey, isBlocked: true)
|
|
|
|
// Force isGeoChat/isGeoDM check to be true by setting prefix?
|
|
// Or ensure the logic covers it.
|
|
// The logic is:
|
|
// if peerID.isGeoChat || peerID.isGeoDM { check nostr }
|
|
// We need a peerID that looks like geo.
|
|
|
|
let geoPeerID = PeerID(nostr_: hexPubkey)
|
|
viewModel.nostrKeyMapping[geoPeerID] = hexPubkey
|
|
|
|
let geoMessage = BitchatMessage(
|
|
id: "msg-geo-blocked",
|
|
sender: "BlockedGeoUser",
|
|
content: "Spam",
|
|
timestamp: Date(),
|
|
isRelay: false,
|
|
isPrivate: true,
|
|
senderPeerID: geoPeerID
|
|
)
|
|
|
|
#expect(viewModel.isMessageBlocked(geoMessage))
|
|
}
|
|
}
|
|
|
|
// MARK: - Nostr Extension Tests
|
|
|
|
struct ChatViewModelNostrExtensionTests {
|
|
|
|
@Test @MainActor
|
|
func switchLocationChannel_mesh_clearsGeo() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
// Setup some geo state
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: "u4pruydq")))
|
|
#expect(viewModel.currentGeohash == "u4pruydq")
|
|
|
|
// Switch to mesh
|
|
viewModel.switchLocationChannel(to: .mesh)
|
|
|
|
#expect(viewModel.activeChannel == .mesh)
|
|
#expect(viewModel.currentGeohash == nil)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func subscribeNostrEvent_addsToTimeline_ifMatchesGeohash() async throws {
|
|
let geohash = "u4pruydq"
|
|
let channel = ChannelID.location(GeohashChannel(level: .city, geohash: geohash))
|
|
|
|
LocationChannelManager.shared.select(channel)
|
|
defer { LocationChannelManager.shared.select(.mesh) }
|
|
|
|
_ = await TestHelpers.waitUntil({ LocationChannelManager.shared.selectedChannel == channel })
|
|
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
|
|
_ = await TestHelpers.waitUntil({ viewModel.activeChannel == channel })
|
|
|
|
let signer = try NostrIdentity.generate()
|
|
let event = NostrEvent(
|
|
pubkey: signer.publicKeyHex,
|
|
createdAt: Date(),
|
|
kind: .ephemeralEvent,
|
|
tags: [["g", geohash]],
|
|
content: "Hello Geo"
|
|
)
|
|
let signed = try event.sign(with: signer.schnorrSigningKey())
|
|
viewModel.handleNostrEvent(signed)
|
|
|
|
let didAppend = await TestHelpers.waitUntil({
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
return viewModel.messages.contains { $0.content == "Hello Geo" }
|
|
})
|
|
#expect(didAppend)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleNostrEvent_ignoresRecentSelfEcho() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
let identity = try viewModel.idBridge.deriveIdentity(forGeohash: geohash)
|
|
|
|
let event = NostrEvent(
|
|
pubkey: identity.publicKeyHex,
|
|
createdAt: Date(),
|
|
kind: .ephemeralEvent,
|
|
tags: [["g", geohash]],
|
|
content: "Self echo"
|
|
)
|
|
let signed = try event.sign(with: identity.schnorrSigningKey())
|
|
viewModel.handleNostrEvent(signed)
|
|
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
|
|
#expect(!viewModel.messages.contains { $0.content == "Self echo" })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleNostrEvent_skipsBlockedSender() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
let blockedIdentity = try NostrIdentity.generate()
|
|
let blockedPubkey = blockedIdentity.publicKeyHex
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
viewModel.identityManager.setNostrBlocked(blockedPubkey, isBlocked: true)
|
|
|
|
let event = NostrEvent(
|
|
pubkey: blockedPubkey,
|
|
createdAt: Date(),
|
|
kind: .ephemeralEvent,
|
|
tags: [["g", geohash]],
|
|
content: "Blocked"
|
|
)
|
|
let signed = try event.sign(with: blockedIdentity.schnorrSigningKey())
|
|
viewModel.handleNostrEvent(signed)
|
|
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
|
|
#expect(!viewModel.messages.contains { $0.content == "Blocked" })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func handleNostrEvent_rejectsInvalidSignature() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
let identity = try NostrIdentity.generate()
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
|
|
let event = NostrEvent(
|
|
pubkey: identity.publicKeyHex,
|
|
createdAt: Date(),
|
|
kind: .ephemeralEvent,
|
|
tags: [["g", geohash]],
|
|
content: "Valid"
|
|
)
|
|
var signed = try event.sign(with: identity.schnorrSigningKey())
|
|
signed.id = "deadbeef"
|
|
|
|
viewModel.handleNostrEvent(signed)
|
|
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
viewModel.publicMessagePipeline.flushIfNeeded()
|
|
|
|
#expect(!viewModel.messages.contains { $0.content == "Tampered" })
|
|
}
|
|
|
|
@Test @MainActor
|
|
func subscribeGiftWrap_rejectsOversizedEmbeddedPacket() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let sender = try NostrIdentity.generate()
|
|
let recipient = try NostrIdentity.generate()
|
|
|
|
let oversized = Data(repeating: 0x41, count: FileTransferLimits.maxFramedFileBytes + 1)
|
|
let content = "bitchat1:" + base64URLEncode(oversized)
|
|
let giftWrap = try NostrProtocol.createPrivateMessage(
|
|
content: content,
|
|
recipientPubkey: recipient.publicKeyHex,
|
|
senderIdentity: sender
|
|
)
|
|
|
|
viewModel.subscribeGiftWrap(giftWrap, id: recipient)
|
|
|
|
try? await Task.sleep(nanoseconds: 100_000_000)
|
|
#expect(viewModel.privateChats.isEmpty)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func switchLocationChannel_clearsNostrDedupCache() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
|
|
viewModel.deduplicationService.recordNostrEvent("evt-cache")
|
|
#expect(viewModel.deduplicationService.hasProcessedNostrEvent("evt-cache"))
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
|
|
#expect(!viewModel.deduplicationService.hasProcessedNostrEvent("evt-cache"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Geohash Queue Tests
|
|
|
|
struct ChatViewModelGeohashQueueTests {
|
|
|
|
@Test @MainActor
|
|
func addGeohashOnlySystemMessage_queuesUntilLocationChannel() async {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
|
|
viewModel.addGeohashOnlySystemMessage("Queued system")
|
|
#expect(!viewModel.messages.contains { $0.content == "Queued system" })
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
|
|
#expect(viewModel.messages.contains { $0.content == "Queued system" })
|
|
}
|
|
}
|
|
|
|
// MARK: - GeoDM Tests
|
|
|
|
struct ChatViewModelGeoDMTests {
|
|
|
|
@Test @MainActor
|
|
func handlePrivateMessage_geohash_dedupsAndTracksAck() async throws {
|
|
let (viewModel, _) = makeTestableViewModel()
|
|
let geohash = "u4pruydq"
|
|
let senderPubkey = "0000000000000000000000000000000000000000000000000000000000000001"
|
|
let messageID = "pm-1"
|
|
|
|
viewModel.switchLocationChannel(to: .location(GeohashChannel(level: .city, geohash: geohash)))
|
|
let identity = try viewModel.idBridge.deriveIdentity(forGeohash: geohash)
|
|
|
|
let convKey = PeerID(nostr_: senderPubkey)
|
|
let packet = PrivateMessagePacket(messageID: messageID, content: "Hello")
|
|
let payloadData = try #require(packet.encode(), "Failed to encode private message")
|
|
let payload = NoisePayload(type: .privateMessage, data: payloadData)
|
|
|
|
viewModel.handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: convKey, id: identity, messageTimestamp: Date())
|
|
viewModel.handlePrivateMessage(payload, senderPubkey: senderPubkey, convKey: convKey, id: identity, messageTimestamp: Date())
|
|
|
|
#expect(viewModel.privateChats[convKey]?.count == 1)
|
|
#expect(viewModel.sentGeoDeliveryAcks.contains(messageID))
|
|
}
|
|
}
|
|
|
|
private func base64URLEncode(_ data: Data) -> String {
|
|
data.base64EncodedString()
|
|
.replacingOccurrences(of: "+", with: "-")
|
|
.replacingOccurrences(of: "/", with: "_")
|
|
.replacingOccurrences(of: "=", with: "")
|
|
}
|