mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-25 02:25:20 +00:00
Merge branch 'main' into feat/courier
Resolve DeliveryStatusView conflict: adopt main's bitchatDescription extension (tooltip + VoiceOver via body modifiers) and fold the .carried case into it, dropping the branch's Strings enum. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
jack
@@ -82,7 +82,7 @@ struct ChatComposerCoordinatorContextTests {
|
||||
context.meshNicknamesByPeerID = [
|
||||
PeerID(str: "1111111111111111"): "alice",
|
||||
PeerID(str: "2222222222222222"): "bob",
|
||||
PeerID(str: "3333333333333333"): "me",
|
||||
PeerID(str: "3333333333333333"): "me"
|
||||
]
|
||||
|
||||
// Matching query: suggestions and range are published, index resets.
|
||||
@@ -113,7 +113,7 @@ struct ChatComposerCoordinatorContextTests {
|
||||
"aaaabbbbccccdddd": "carol",
|
||||
// Own token (nickname#last-4-of-pubkey) must be removed; the dummy
|
||||
// identity's public key hex ends in "2222".
|
||||
"ffffeeeeddddcccc2222": "me",
|
||||
"ffffeeeeddddcccc2222": "me"
|
||||
]
|
||||
|
||||
coordinator.updateAutocomplete(for: "@ca", cursorPosition: 3)
|
||||
|
||||
@@ -214,10 +214,10 @@ struct ChatLifecycleCoordinatorContextTests {
|
||||
// Same message under both keys: the read copy must win over sent.
|
||||
context.privateChats[peerID] = [
|
||||
makePrivateMessage(id: "m1", timestamp: t1, deliveryStatus: .sent),
|
||||
makePrivateMessage(id: "m2", timestamp: t2),
|
||||
makePrivateMessage(id: "m2", timestamp: t2)
|
||||
]
|
||||
context.privateChats[stablePeerID] = [
|
||||
makePrivateMessage(id: "m1", timestamp: t1, deliveryStatus: .read(by: "alice", at: t2)),
|
||||
makePrivateMessage(id: "m1", timestamp: t1, deliveryStatus: .read(by: "alice", at: t2))
|
||||
]
|
||||
|
||||
let merged = coordinator.getPrivateChatMessages(for: peerID)
|
||||
@@ -245,7 +245,7 @@ struct ChatLifecycleCoordinatorContextTests {
|
||||
makePrivateMessage(id: "m1", senderPeerID: convKey),
|
||||
makePrivateMessage(id: "already-acked", senderPeerID: convKey),
|
||||
makePrivateMessage(id: "relay", senderPeerID: convKey, isRelay: true),
|
||||
makePrivateMessage(id: "mine", sender: "me", senderPeerID: context.myPeerID),
|
||||
makePrivateMessage(id: "mine", sender: "me", senderPeerID: context.myPeerID)
|
||||
]
|
||||
|
||||
coordinator.markPrivateMessagesAsRead(from: convKey)
|
||||
@@ -339,7 +339,7 @@ struct ChatLifecycleCoordinatorContextTests {
|
||||
)
|
||||
context.privateChats[peerID] = [
|
||||
makePrivateMessage(id: "in-1", senderPeerID: peerID),
|
||||
makePrivateMessage(id: "in-relay", senderPeerID: peerID, isRelay: true),
|
||||
makePrivateMessage(id: "in-relay", senderPeerID: peerID, isRelay: true)
|
||||
]
|
||||
|
||||
coordinator.markPrivateMessagesAsRead(from: peerID)
|
||||
|
||||
@@ -154,18 +154,18 @@ struct ChatPeerListCoordinatorContextTests {
|
||||
peerID: currentPeer,
|
||||
noisePublicKey: Data(repeating: 0x01, count: 32),
|
||||
nickname: "alice"
|
||||
),
|
||||
)
|
||||
]
|
||||
context.unreadPrivateMessages = [
|
||||
currentPeer,
|
||||
staleShortPeer,
|
||||
geoDMWithMessages,
|
||||
geoDMWithoutMessages,
|
||||
noiseKeyWithMessages,
|
||||
noiseKeyWithMessages
|
||||
]
|
||||
context.privateChats = [
|
||||
geoDMWithMessages: [makeMessage(id: "geo-1")],
|
||||
noiseKeyWithMessages: [makeMessage(id: "noise-1")],
|
||||
noiseKeyWithMessages: [makeMessage(id: "noise-1")]
|
||||
]
|
||||
|
||||
coordinator.didUpdatePeerList([currentPeer])
|
||||
|
||||
@@ -352,7 +352,7 @@ struct ChatPrivateConversationCoordinatorContextTests {
|
||||
context.displayNamesByPubkey[senderPubkey] = "alice#1234"
|
||||
context.privateChats[convKey] = [
|
||||
makeIncomingMessage(id: "mine-1", sender: "me"),
|
||||
makeIncomingMessage(id: "mine-2", sender: "me"),
|
||||
makeIncomingMessage(id: "mine-2", sender: "me")
|
||||
]
|
||||
|
||||
coordinator.handleDelivered(
|
||||
|
||||
@@ -259,7 +259,7 @@ struct ChatTransportEventCoordinatorContextTests {
|
||||
context.privateChats[peerID] = [
|
||||
makeMessage(id: "theirs-1", isPrivate: true, senderPeerID: peerID),
|
||||
makeMessage(id: "mine-1", sender: "me", isPrivate: true, senderPeerID: context.myPeerID),
|
||||
makeMessage(id: "theirs-2", isPrivate: true, senderPeerID: peerID),
|
||||
makeMessage(id: "theirs-2", isPrivate: true, senderPeerID: peerID)
|
||||
]
|
||||
coordinator.didDisconnectFromPeer(peerID)
|
||||
await drainMainActorTasks()
|
||||
@@ -282,7 +282,7 @@ struct ChatTransportEventCoordinatorContextTests {
|
||||
context.unreadPrivateMessages = [peerID]
|
||||
context.privateChats[peerID] = [
|
||||
makeMessage(id: "m1", isPrivate: true, senderPeerID: peerID),
|
||||
makeMessage(id: "mine", sender: "me", isPrivate: true, senderPeerID: context.myPeerID),
|
||||
makeMessage(id: "mine", sender: "me", isPrivate: true, senderPeerID: context.myPeerID)
|
||||
]
|
||||
|
||||
coordinator.didDisconnectFromPeer(peerID)
|
||||
|
||||
@@ -297,8 +297,23 @@ struct ChatViewModelNostrExtensionTests {
|
||||
|
||||
let didAppend = await TestHelpers.waitUntil({
|
||||
viewModel.publicMessagePipeline.flushIfNeeded()
|
||||
return viewModel.messages.contains { $0.content == "Hello Geo" }
|
||||
})
|
||||
if viewModel.messages.contains(where: { $0.content == "Hello Geo" }) { return true }
|
||||
// LocationChannelManager is a process-wide singleton: a suite
|
||||
// running in parallel (e.g. CommandProcessorTests) can flip the
|
||||
// selected channel mid-test, which reroutes or drops the event
|
||||
// permanently — no amount of waiting recovers it. Re-assert the
|
||||
// channel and redeliver on each poll: every channel switch clears
|
||||
// the processed-event set and the store dedups by message ID, so
|
||||
// redelivery is idempotent and interference heals on the next
|
||||
// poll while a genuine failure still times out.
|
||||
if LocationChannelManager.shared.selectedChannel != channel {
|
||||
LocationChannelManager.shared.select(channel)
|
||||
}
|
||||
if viewModel.activeChannel == channel {
|
||||
viewModel.handleNostrEvent(signed)
|
||||
}
|
||||
return false
|
||||
}, timeout: TestConstants.longTimeout)
|
||||
#expect(didAppend)
|
||||
}
|
||||
|
||||
@@ -1000,7 +1015,11 @@ struct ChatViewModelMediaTransferTests {
|
||||
viewModel.selectedPrivateChatPeer = peerID
|
||||
viewModel.sendVoiceNote(at: url)
|
||||
|
||||
let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: 5.0)
|
||||
// Media sends hop through Task.detached; the global executor is
|
||||
// shared with every parallel test worker, so a loaded runner can
|
||||
// exceed the 5s default. waitUntil returns as soon as the condition
|
||||
// holds, so passing runs never pay the longer timeout.
|
||||
let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: TestConstants.longTimeout)
|
||||
#expect(didSend)
|
||||
#expect(transport.sentPrivateFiles.first?.peerID == peerID)
|
||||
#expect(viewModel.privateChats[peerID]?.last?.content.contains("[voice]") == true)
|
||||
@@ -1020,7 +1039,7 @@ struct ChatViewModelMediaTransferTests {
|
||||
|
||||
let didFail = await TestHelpers.waitUntil({
|
||||
isFailed(status: viewModel.privateChats[peerID]?.last?.deliveryStatus)
|
||||
}, timeout: 5.0)
|
||||
}, timeout: TestConstants.longTimeout)
|
||||
#expect(didFail)
|
||||
#expect(!FileManager.default.fileExists(atPath: url.path))
|
||||
#expect(transport.sentPrivateFiles.isEmpty)
|
||||
@@ -1036,7 +1055,7 @@ struct ChatViewModelMediaTransferTests {
|
||||
viewModel.selectedPrivateChatPeer = peerID
|
||||
viewModel.sendImage(from: sourceURL)
|
||||
|
||||
let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: 5.0)
|
||||
let didSend = await TestHelpers.waitUntil({ transport.sentPrivateFiles.count == 1 }, timeout: TestConstants.longTimeout)
|
||||
#expect(didSend)
|
||||
#expect(transport.sentPrivateFiles.first?.peerID == peerID)
|
||||
#expect(transport.sentPrivateFiles.first?.packet.mimeType == "image/jpeg")
|
||||
@@ -1057,7 +1076,7 @@ struct ChatViewModelMediaTransferTests {
|
||||
|
||||
let didNotify = await TestHelpers.waitUntil({
|
||||
viewModel.messages.contains(where: { $0.sender == "system" && $0.content.contains("Failed to prepare image") })
|
||||
}, timeout: 5.0)
|
||||
}, timeout: TestConstants.longTimeout)
|
||||
#expect(didNotify)
|
||||
#expect(transport.sentPrivateFiles.isEmpty)
|
||||
#expect(viewModel.privateChats[peerID]?.isEmpty != false)
|
||||
|
||||
@@ -263,6 +263,59 @@ struct ChatViewModelCommandTests {
|
||||
#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
|
||||
|
||||
@@ -174,7 +174,7 @@ struct IntegrationTests {
|
||||
}
|
||||
|
||||
// Encrypted path: use NoiseSessionManager explicitly
|
||||
let plaintext = "Encrypted message".data(using: .utf8)!
|
||||
let plaintext = Data("Encrypted message".utf8)
|
||||
let ciphertext = try helper.noiseManagers["Alice"]!.encrypt(plaintext, for: helper.nodes["Bob"]!.peerID)
|
||||
|
||||
helper.nodes["Bob"]!.packetDeliveryHandler = { packet in
|
||||
@@ -206,7 +206,7 @@ struct IntegrationTests {
|
||||
|
||||
try await confirmation("Messages delivered despite churn", expectedCount: totalMessages) { completion in
|
||||
// David tracks received messages
|
||||
helper.nodes["David"]!.messageDeliveryHandler = { message in
|
||||
helper.nodes["David"]!.messageDeliveryHandler = { _ in
|
||||
completion()
|
||||
}
|
||||
|
||||
@@ -288,7 +288,7 @@ struct IntegrationTests {
|
||||
}
|
||||
|
||||
do {
|
||||
let plaintext = "After restart success".data(using: .utf8)!
|
||||
let plaintext = Data("After restart success".utf8)
|
||||
let ciphertext = try helper.noiseManagers["Bob"]!.encrypt(plaintext, for: helper.nodes["Alice"]!.peerID)
|
||||
let packet = TestHelpers.createTestPacket(type: MessageType.noiseEncrypted.rawValue, payload: ciphertext)
|
||||
helper.nodes["Alice"]!.packetDeliveryHandler = { pkt in
|
||||
|
||||
@@ -121,4 +121,3 @@ final class TestNetworkHelper {
|
||||
_ = try manager2.handleIncomingHandshake(from: peer1ID, message: msg3)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -52,19 +52,19 @@ struct MimeTypeTests {
|
||||
@Test(arguments: [
|
||||
// === Image types ===
|
||||
(MimeType.jpeg, [0xFF, 0xD8, 0xFF]),
|
||||
(MimeType.png, [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
|
||||
(MimeType.gif, [0x47, 0x49, 0x46, 0x38, 0x39, 0x61]), // "GIF89a"
|
||||
(MimeType.png, [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
|
||||
(MimeType.gif, [0x47, 0x49, 0x46, 0x38, 0x39, 0x61]), // "GIF89a"
|
||||
(MimeType.webp, [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00,
|
||||
0x57, 0x45, 0x42, 0x50]), // "RIFF....WEBP"
|
||||
|
||||
// === Audio types ===
|
||||
(MimeType.mp3, [0x49, 0x44, 0x33]), // "ID3"
|
||||
(MimeType.wav, [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00,
|
||||
(MimeType.mp3, [0x49, 0x44, 0x33]), // "ID3"
|
||||
(MimeType.wav, [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00,
|
||||
0x57, 0x41, 0x56, 0x45]), // "RIFF....WAVE"
|
||||
(MimeType.ogg, [0x4F, 0x67, 0x67, 0x53]), // "OggS"
|
||||
(MimeType.ogg, [0x4F, 0x67, 0x67, 0x53]), // "OggS"
|
||||
|
||||
// === Application types ===
|
||||
(MimeType.pdf, [0x25, 0x50, 0x44, 0x46]) // "%PDF"
|
||||
(MimeType.pdf, [0x25, 0x50, 0x44, 0x46]) // "%PDF"
|
||||
])
|
||||
func validSignatures(mime: MimeType, bytes: [UInt8]) throws {
|
||||
let data = Data(bytes)
|
||||
|
||||
@@ -172,7 +172,7 @@ struct NoiseCoverageTests {
|
||||
Data(),
|
||||
Data(repeating: 0x00, count: 32),
|
||||
Data([0x01] + Array(repeating: 0x00, count: 31)),
|
||||
Data(repeating: 0xFF, count: 32),
|
||||
Data(repeating: 0xFF, count: 32)
|
||||
]
|
||||
|
||||
for invalidKey in invalidKeys {
|
||||
|
||||
@@ -151,7 +151,7 @@ struct NoiseProtocolTests {
|
||||
@Test func basicEncryptionDecryption() throws {
|
||||
try performHandshake(initiator: aliceSession, responder: bobSession)
|
||||
|
||||
let plaintext = "Hello, Bob!".data(using: .utf8)!
|
||||
let plaintext = Data("Hello, Bob!".utf8)
|
||||
|
||||
// Alice encrypts
|
||||
let ciphertext = try aliceSession.encrypt(plaintext)
|
||||
@@ -167,13 +167,13 @@ struct NoiseProtocolTests {
|
||||
try performHandshake(initiator: aliceSession, responder: bobSession)
|
||||
|
||||
// Alice -> Bob
|
||||
let aliceMessage = "Hello from Alice".data(using: .utf8)!
|
||||
let aliceMessage = Data("Hello from Alice".utf8)
|
||||
let aliceCiphertext = try aliceSession.encrypt(aliceMessage)
|
||||
let bobReceived = try bobSession.decrypt(aliceCiphertext)
|
||||
#expect(bobReceived == aliceMessage)
|
||||
|
||||
// Bob -> Alice
|
||||
let bobMessage = "Hello from Bob".data(using: .utf8)!
|
||||
let bobMessage = Data("Hello from Bob".utf8)
|
||||
let bobCiphertext = try bobSession.encrypt(bobMessage)
|
||||
let aliceReceived = try aliceSession.decrypt(bobCiphertext)
|
||||
#expect(aliceReceived == bobMessage)
|
||||
@@ -193,7 +193,7 @@ struct NoiseProtocolTests {
|
||||
}
|
||||
|
||||
@Test func encryptionBeforeHandshake() {
|
||||
let plaintext = "test".data(using: .utf8)!
|
||||
let plaintext = Data("test".utf8)
|
||||
|
||||
#expect(throws: NoiseSessionError.notEstablished) {
|
||||
try aliceSession.encrypt(plaintext)
|
||||
@@ -270,7 +270,7 @@ struct NoiseProtocolTests {
|
||||
try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
|
||||
|
||||
// Encrypt with manager
|
||||
let plaintext = "Test message".data(using: .utf8)!
|
||||
let plaintext = Data("Test message".utf8)
|
||||
let ciphertext = try aliceManager.encrypt(plaintext, for: alicePeerID)
|
||||
|
||||
// Decrypt with manager
|
||||
@@ -283,7 +283,7 @@ struct NoiseProtocolTests {
|
||||
@Test func tamperedCiphertextDetection() throws {
|
||||
try performHandshake(initiator: aliceSession, responder: bobSession)
|
||||
|
||||
let plaintext = "Secret message".data(using: .utf8)!
|
||||
let plaintext = Data("Secret message".utf8)
|
||||
var ciphertext = try aliceSession.encrypt(plaintext)
|
||||
|
||||
// Tamper with ciphertext
|
||||
@@ -304,7 +304,7 @@ struct NoiseProtocolTests {
|
||||
@Test func replayPrevention() throws {
|
||||
try performHandshake(initiator: aliceSession, responder: bobSession)
|
||||
|
||||
let plaintext = "Test message".data(using: .utf8)!
|
||||
let plaintext = Data("Test message".utf8)
|
||||
let ciphertext = try aliceSession.encrypt(plaintext)
|
||||
|
||||
// First decryption should succeed
|
||||
@@ -337,7 +337,7 @@ struct NoiseProtocolTests {
|
||||
try performHandshake(initiator: aliceSession2, responder: bobSession2)
|
||||
|
||||
// Encrypt with session 1
|
||||
let plaintext = "Secret".data(using: .utf8)!
|
||||
let plaintext = Data("Secret".utf8)
|
||||
let ciphertext1 = try aliceSession1.encrypt(plaintext)
|
||||
|
||||
// Should not be able to decrypt with session 2
|
||||
@@ -366,10 +366,10 @@ struct NoiseProtocolTests {
|
||||
try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
|
||||
|
||||
// Exchange some messages to establish nonce state
|
||||
let message1 = try aliceManager.encrypt("Hello".data(using: .utf8)!, for: alicePeerID)
|
||||
let message1 = try aliceManager.encrypt(Data("Hello".utf8), for: alicePeerID)
|
||||
_ = try bobManager.decrypt(message1, from: bobPeerID)
|
||||
|
||||
let message2 = try bobManager.encrypt("World".data(using: .utf8)!, for: bobPeerID)
|
||||
let message2 = try bobManager.encrypt(Data("World".utf8), for: bobPeerID)
|
||||
_ = try aliceManager.decrypt(message2, from: alicePeerID)
|
||||
|
||||
// Simulate Bob restart by creating new manager with same key
|
||||
@@ -391,7 +391,7 @@ struct NoiseProtocolTests {
|
||||
_ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: newHandshake3!)
|
||||
|
||||
// Should be able to exchange messages with new sessions
|
||||
let testMessage = "After restart".data(using: .utf8)!
|
||||
let testMessage = Data("After restart".utf8)
|
||||
let encrypted = try bobManagerRestarted.encrypt(testMessage, for: bobPeerID)
|
||||
let decrypted = try aliceManager.decrypt(encrypted, from: alicePeerID)
|
||||
#expect(decrypted == testMessage)
|
||||
@@ -409,17 +409,17 @@ struct NoiseProtocolTests {
|
||||
|
||||
// Exchange messages to advance nonces
|
||||
for i in 0..<5 {
|
||||
let msg = try aliceSession.encrypt("Message \(i)".data(using: .utf8)!)
|
||||
let msg = try aliceSession.encrypt(Data("Message \(i)".utf8))
|
||||
_ = try bobSession.decrypt(msg)
|
||||
}
|
||||
|
||||
// Simulate desynchronization by encrypting but not decrypting
|
||||
for i in 0..<3 {
|
||||
_ = try aliceSession.encrypt("Lost message \(i)".data(using: .utf8)!)
|
||||
_ = try aliceSession.encrypt(Data("Lost message \(i)".utf8))
|
||||
}
|
||||
|
||||
// With per-packet nonce carried, decryption should not throw here
|
||||
let desyncMessage = try aliceSession.encrypt("This now succeeds".data(using: .utf8)!)
|
||||
let desyncMessage = try aliceSession.encrypt(Data("This now succeeds".utf8))
|
||||
#expect(throws: Never.self) {
|
||||
try bobSession.decrypt(desyncMessage)
|
||||
}
|
||||
@@ -434,12 +434,11 @@ struct NoiseProtocolTests {
|
||||
|
||||
let messageCount = 100
|
||||
|
||||
try await confirmation("All messages encrypted and decrypted", expectedCount: messageCount)
|
||||
{ completion in
|
||||
try await confirmation("All messages encrypted and decrypted", expectedCount: messageCount) { completion in
|
||||
var encryptedMessages: [Int: Data] = [:]
|
||||
// Encrypt messages sequentially to avoid nonce races in manager
|
||||
for i in 0..<messageCount {
|
||||
let plaintext = "Concurrent message \(i)".data(using: .utf8)!
|
||||
let plaintext = Data("Concurrent message \(i)".utf8)
|
||||
let encrypted = try aliceManager.encrypt(plaintext, for: alicePeerID)
|
||||
encryptedMessages[i] = encrypted
|
||||
}
|
||||
@@ -452,7 +451,7 @@ struct NoiseProtocolTests {
|
||||
return
|
||||
}
|
||||
let decrypted = try bobManager.decrypt(encrypted, from: bobPeerID)
|
||||
let expected = "Concurrent message \(i)".data(using: .utf8)!
|
||||
let expected = Data("Concurrent message \(i)".utf8)
|
||||
#expect(decrypted == expected)
|
||||
completion()
|
||||
} catch {
|
||||
@@ -485,7 +484,7 @@ struct NoiseProtocolTests {
|
||||
try establishManagerSessions(aliceManager: aliceManager, bobManager: bobManager)
|
||||
|
||||
// Create a corrupted message
|
||||
var encrypted = try aliceManager.encrypt("Test".data(using: .utf8)!, for: alicePeerID)
|
||||
var encrypted = try aliceManager.encrypt(Data("Test".utf8), for: alicePeerID)
|
||||
encrypted[10] ^= 0xFF // Corrupt the data
|
||||
|
||||
// Decryption should fail
|
||||
@@ -516,7 +515,7 @@ struct NoiseProtocolTests {
|
||||
#expect(bobManager.getSession(for: bobPeerID)?.isEstablished() == true)
|
||||
|
||||
// Exchange messages to verify sessions work
|
||||
let testMessage = "Session works".data(using: .utf8)!
|
||||
let testMessage = Data("Session works".utf8)
|
||||
let encrypted = try aliceManager.encrypt(testMessage, for: alicePeerID)
|
||||
let decrypted = try bobManager.decrypt(encrypted, from: bobPeerID)
|
||||
#expect(decrypted == testMessage)
|
||||
@@ -539,7 +538,7 @@ struct NoiseProtocolTests {
|
||||
_ = try bobManager.handleIncomingHandshake(from: bobPeerID, message: newHandshake3!)
|
||||
|
||||
// Verify new sessions work
|
||||
let testMessage2 = "New session works".data(using: .utf8)!
|
||||
let testMessage2 = Data("New session works".utf8)
|
||||
let encrypted2 = try aliceManager.encrypt(testMessage2, for: alicePeerID)
|
||||
let decrypted2 = try bobManager.decrypt(encrypted2, from: bobPeerID)
|
||||
#expect(decrypted2 == testMessage2)
|
||||
@@ -555,18 +554,18 @@ struct NoiseProtocolTests {
|
||||
|
||||
// Exchange messages normally
|
||||
for i in 0..<5 {
|
||||
let msg = try aliceManager.encrypt("Message \(i)".data(using: .utf8)!, for: alicePeerID)
|
||||
let msg = try aliceManager.encrypt(Data("Message \(i)".utf8), for: alicePeerID)
|
||||
_ = try bobManager.decrypt(msg, from: bobPeerID)
|
||||
}
|
||||
|
||||
// Simulate desynchronization - Alice sends messages that Bob doesn't receive
|
||||
for i in 0..<3 {
|
||||
_ = try aliceManager.encrypt("Lost message \(i)".data(using: .utf8)!, for: alicePeerID)
|
||||
_ = try aliceManager.encrypt(Data("Lost message \(i)".utf8), for: alicePeerID)
|
||||
}
|
||||
|
||||
// With nonce carried in packet, decryption should not throw here
|
||||
let desyncMessage = try aliceManager.encrypt(
|
||||
"This now succeeds".data(using: .utf8)!, for: alicePeerID)
|
||||
Data("This now succeeds".utf8), for: alicePeerID)
|
||||
#expect(throws: Never.self) {
|
||||
try bobManager.decrypt(desyncMessage, from: bobPeerID)
|
||||
}
|
||||
@@ -587,7 +586,7 @@ struct NoiseProtocolTests {
|
||||
_ = try aliceManager.handleIncomingHandshake(from: alicePeerID, message: rehandshake3!)
|
||||
|
||||
// Verify communication works again
|
||||
let testResynced = "Resynced".data(using: .utf8)!
|
||||
let testResynced = Data("Resynced".utf8)
|
||||
let encryptedResync = try aliceManager.encrypt(testResynced, for: alicePeerID)
|
||||
let decryptedResync = try bobManager.decrypt(encryptedResync, from: bobPeerID)
|
||||
#expect(decryptedResync == testResynced)
|
||||
@@ -900,20 +899,20 @@ struct NoiseProtocolTests {
|
||||
#expect(trackingKeychain.secureClearDataCallCount > 0)
|
||||
|
||||
// Test encryption from Alice to Bob
|
||||
let plaintext1 = "Hello from Alice after secureClear!".data(using: .utf8)!
|
||||
let plaintext1 = Data("Hello from Alice after secureClear!".utf8)
|
||||
let ciphertext1 = try alice.encrypt(plaintext1)
|
||||
let decrypted1 = try bob.decrypt(ciphertext1)
|
||||
#expect(decrypted1 == plaintext1)
|
||||
|
||||
// Test encryption from Bob to Alice
|
||||
let plaintext2 = "Hello from Bob after secureClear!".data(using: .utf8)!
|
||||
let plaintext2 = Data("Hello from Bob after secureClear!".utf8)
|
||||
let ciphertext2 = try bob.encrypt(plaintext2)
|
||||
let decrypted2 = try alice.decrypt(ciphertext2)
|
||||
#expect(decrypted2 == plaintext2)
|
||||
|
||||
// Test multiple messages to verify cipher state is correct
|
||||
for i in 1...10 {
|
||||
let msg = "Message \(i) from Alice".data(using: .utf8)!
|
||||
let msg = Data("Message \(i) from Alice".utf8)
|
||||
let cipher = try alice.encrypt(msg)
|
||||
let dec = try bob.decrypt(cipher)
|
||||
#expect(dec == msg)
|
||||
|
||||
@@ -301,7 +301,7 @@ final class PerformanceBaselineTests: XCTestCase {
|
||||
("@carol#a1b2 did you see this? https://example.com/threads/42", ["carol"]),
|
||||
("checking in from the harbor #bitchat #mesh", nil),
|
||||
("@bob#0042 ping me when you get this", ["bob#0042"]),
|
||||
("long form update with a link https://news.example.org/articles/2026/06/mesh-networks and a tag #geohash", nil),
|
||||
("long form update with a link https://news.example.org/articles/2026/06/mesh-networks and a tag #geohash", nil)
|
||||
]
|
||||
let batches: [[BitchatMessage]] = (0..<batchCount).map { batch in
|
||||
(0..<batchSize).map { i in
|
||||
@@ -547,7 +547,7 @@ final class PerformanceBaselineTests: XCTestCase {
|
||||
"anyone near the station?",
|
||||
"@bob#0042 are you on mesh too?",
|
||||
"check this out https://example.com/p/123 #bitchat",
|
||||
"teleport check, who's local?",
|
||||
"teleport check, who's local?"
|
||||
]
|
||||
return try (0..<count).map { i in
|
||||
try NostrProtocol.createEphemeralGeohashEvent(
|
||||
|
||||
@@ -50,14 +50,19 @@ private final class DefaultTransportProbe: Transport {
|
||||
struct ProtocolContractTests {
|
||||
@Test
|
||||
func commandInfo_exposesAliasesPlaceholdersAndGeoVariants() {
|
||||
#expect(CommandInfo.message.id == "dm")
|
||||
#expect(CommandInfo.message.alias == "/dm")
|
||||
// Aliases must match what CommandProcessor actually accepts —
|
||||
// the suggestion panel is the only command-discovery surface.
|
||||
#expect(CommandInfo.message.id == "msg")
|
||||
#expect(CommandInfo.message.alias == "/msg")
|
||||
#expect(CommandInfo.message.placeholder != nil)
|
||||
#expect(CommandInfo.clear.placeholder == nil)
|
||||
#expect(CommandInfo.favorite.description.isEmpty == false)
|
||||
#expect(CommandInfo.all(isGeoPublic: false, isGeoDM: false).contains(.favorite) == false)
|
||||
#expect(CommandInfo.all(isGeoPublic: true, isGeoDM: false).contains(.favorite))
|
||||
#expect(CommandInfo.all(isGeoPublic: false, isGeoDM: true).contains(.unfavorite))
|
||||
#expect(CommandInfo.all(isGeoPublic: false, isGeoDM: false).contains(.help))
|
||||
// Favorites are rejected by the processor in geohash contexts, so
|
||||
// they are suggested only in mesh.
|
||||
#expect(CommandInfo.all(isGeoPublic: false, isGeoDM: false).contains(.favorite))
|
||||
#expect(CommandInfo.all(isGeoPublic: true, isGeoDM: false).contains(.favorite) == false)
|
||||
#expect(CommandInfo.all(isGeoPublic: false, isGeoDM: true).contains(.unfavorite) == false)
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -41,6 +41,44 @@ struct UnifiedPeerServiceTests {
|
||||
|
||||
#expect(service.isBlocked(peerID))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func setBlocked_persistsByFingerprintAndToggles() async {
|
||||
let transport = MockTransport()
|
||||
let identity = TestIdentityManager()
|
||||
let idBridge = NostrIdentityBridge(keychain: MockKeychainHelper())
|
||||
let service = UnifiedPeerService(meshService: transport, idBridge: idBridge, identityManager: identity)
|
||||
|
||||
let peerID = PeerID(str: "00000000000000EE")
|
||||
let fingerprint = "fp-target"
|
||||
transport.peerFingerprints[peerID] = fingerprint
|
||||
|
||||
// Blocking resolves and persists by the peer's fingerprint.
|
||||
let resolved = service.setBlocked(peerID, blocked: true)
|
||||
#expect(resolved == fingerprint)
|
||||
#expect(identity.isBlocked(fingerprint: fingerprint))
|
||||
#expect(service.isBlocked(peerID))
|
||||
|
||||
// Unblocking clears it against the same identity.
|
||||
let unresolved = service.setBlocked(peerID, blocked: false)
|
||||
#expect(unresolved == fingerprint)
|
||||
#expect(!identity.isBlocked(fingerprint: fingerprint))
|
||||
#expect(!service.isBlocked(peerID))
|
||||
}
|
||||
|
||||
@Test @MainActor
|
||||
func setBlocked_unknownIdentityReturnsNil() async {
|
||||
let transport = MockTransport()
|
||||
let identity = TestIdentityManager()
|
||||
let idBridge = NostrIdentityBridge(keychain: MockKeychainHelper())
|
||||
let service = UnifiedPeerService(meshService: transport, idBridge: idBridge, identityManager: identity)
|
||||
|
||||
// No fingerprint resolvable for this peer (offline & unknown).
|
||||
let peerID = PeerID(str: "00000000000000FF")
|
||||
|
||||
#expect(service.setBlocked(peerID, blocked: true) == nil)
|
||||
#expect(!service.isBlocked(peerID))
|
||||
}
|
||||
}
|
||||
|
||||
private final class TestIdentityManager: SecureIdentityStateManagerProtocol {
|
||||
|
||||
@@ -12,6 +12,11 @@ import Foundation
|
||||
struct TestConstants {
|
||||
static let defaultTimeout: TimeInterval = 5.0
|
||||
static let shortTimeout: TimeInterval = 1.0
|
||||
/// For positive waits on work that hops through `Task.detached` or
|
||||
/// background queues: those contend with every parallel test worker for
|
||||
/// the global executor, so a loaded CI runner can exceed
|
||||
/// `defaultTimeout`. `waitUntil` returns as soon as the condition holds,
|
||||
/// so passing runs never pay the longer timeout.
|
||||
static let longTimeout: TimeInterval = 10.0
|
||||
|
||||
static let testNickname1 = "Alice"
|
||||
|
||||
@@ -54,13 +54,13 @@ final class TestHelpers {
|
||||
type: UInt8 = 0x01,
|
||||
senderID: PeerID = PeerID(str: UUID().uuidString),
|
||||
recipientID: PeerID? = nil,
|
||||
payload: Data = "test payload".data(using: .utf8)!,
|
||||
payload: Data = Data("test payload".utf8),
|
||||
signature: Data? = nil,
|
||||
ttl: UInt8 = 3
|
||||
) -> BitchatPacket {
|
||||
return BitchatPacket(
|
||||
type: type,
|
||||
senderID: senderID.id.data(using: .utf8)!,
|
||||
senderID: Data(senderID.id.utf8),
|
||||
recipientID: recipientID?.id.data(using: .utf8),
|
||||
timestamp: UInt64(Date().timeIntervalSince1970 * 1000),
|
||||
payload: payload,
|
||||
|
||||
@@ -556,11 +556,19 @@ struct ViewSmokeTests {
|
||||
@Test
|
||||
func voiceAndMediaViews_renderAndWarmCaches() async throws {
|
||||
let audioURL = try makeTemporaryAudioURL()
|
||||
// Probed directly below. Deliberately a separate file from `audioURL`:
|
||||
// `WaveformCache.shared` is process-wide and the mounted
|
||||
// `VoiceNoteView` warms it for `audioURL` at the view's default bin
|
||||
// width concurrently, so asserting an exact bin count for that URL
|
||||
// races with the view's own cache write.
|
||||
let waveformProbeURL = try makeTemporaryAudioURL()
|
||||
let imageURL = try makeTemporaryImageURL()
|
||||
defer {
|
||||
try? FileManager.default.removeItem(at: audioURL)
|
||||
try? FileManager.default.removeItem(at: waveformProbeURL)
|
||||
try? FileManager.default.removeItem(at: imageURL)
|
||||
WaveformCache.shared.purge(url: audioURL)
|
||||
WaveformCache.shared.purge(url: waveformProbeURL)
|
||||
}
|
||||
|
||||
let waveformView = WaveformView(
|
||||
@@ -594,12 +602,14 @@ struct ViewSmokeTests {
|
||||
_ = mount(voiceNoteView)
|
||||
|
||||
let bins = await withCheckedContinuation { continuation in
|
||||
WaveformCache.shared.waveform(for: audioURL, bins: 16) { values in
|
||||
WaveformCache.shared.waveform(for: waveformProbeURL, bins: 16) { values in
|
||||
continuation.resume(returning: values)
|
||||
}
|
||||
}
|
||||
playback.loadDuration()
|
||||
try? await Task.sleep(nanoseconds: 250_000_000)
|
||||
// loadDuration hops through a background queue and back to main; poll
|
||||
// instead of a fixed sleep so a loaded runner can't outlast the wait.
|
||||
_ = await TestHelpers.waitUntil({ playback.duration > 0 })
|
||||
playback.seek(to: 1.25)
|
||||
playback.stop()
|
||||
VoiceNotePlaybackCoordinator.shared.activate(playback)
|
||||
@@ -607,7 +617,7 @@ struct ViewSmokeTests {
|
||||
await VoiceRecorder.shared.cancelRecording()
|
||||
|
||||
#expect(bins.count == 16)
|
||||
#expect(WaveformCache.shared.cachedWaveform(for: audioURL)?.count == 16)
|
||||
#expect(WaveformCache.shared.cachedWaveform(for: waveformProbeURL)?.count == 16)
|
||||
#expect(playback.duration > 0)
|
||||
#expect(playback.progress == 0)
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@ import struct Foundation.Data
|
||||
struct XChaCha20Poly1305CompatTests {
|
||||
|
||||
@Test func sealAndOpenRoundtrip() throws {
|
||||
let plaintext = "Hello, XChaCha20-Poly1305!".data(using: .utf8)!
|
||||
let plaintext = Data("Hello, XChaCha20-Poly1305!".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
|
||||
@@ -29,10 +29,10 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealAndOpenWithAAD() throws {
|
||||
let plaintext = "Secret message".data(using: .utf8)!
|
||||
let plaintext = Data("Secret message".utf8)
|
||||
let key = Data(repeating: 0xAB, count: 32)
|
||||
let nonce = Data(repeating: 0xCD, count: 24)
|
||||
let aad = "additional authenticated data".data(using: .utf8)!
|
||||
let aad = Data("additional authenticated data".utf8)
|
||||
|
||||
let sealed = try XChaCha20Poly1305Compat.seal(plaintext: plaintext, key: key, nonce24: nonce, aad: aad)
|
||||
let decrypted = try XChaCha20Poly1305Compat.open(
|
||||
@@ -47,7 +47,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealProducesDifferentCiphertextWithDifferentNonces() throws {
|
||||
let plaintext = "Same plaintext".data(using: .utf8)!
|
||||
let plaintext = Data("Same plaintext".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let nonce1 = Data(repeating: 0x01, count: 24)
|
||||
let nonce2 = Data(repeating: 0x02, count: 24)
|
||||
@@ -59,7 +59,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnShortKey() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let shortKey = Data(repeating: 0x42, count: 16)
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
|
||||
@@ -73,7 +73,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnLongKey() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let longKey = Data(repeating: 0x42, count: 64)
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
|
||||
@@ -87,7 +87,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnEmptyKey() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let emptyKey = Data()
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
|
||||
@@ -116,7 +116,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnShortNonce() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let shortNonce = Data(repeating: 0x24, count: 12)
|
||||
|
||||
@@ -130,7 +130,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnLongNonce() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let longNonce = Data(repeating: 0x24, count: 32)
|
||||
|
||||
@@ -144,7 +144,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func sealThrowsOnEmptyNonce() {
|
||||
let plaintext = "Test".data(using: .utf8)!
|
||||
let plaintext = Data("Test".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let emptyNonce = Data()
|
||||
|
||||
@@ -173,7 +173,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func openFailsWithWrongKey() throws {
|
||||
let plaintext = "Secret".data(using: .utf8)!
|
||||
let plaintext = Data("Secret".utf8)
|
||||
let correctKey = Data(repeating: 0x42, count: 32)
|
||||
let wrongKey = Data(repeating: 0x43, count: 32)
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
@@ -195,7 +195,7 @@ struct XChaCha20Poly1305CompatTests {
|
||||
}
|
||||
|
||||
@Test func openFailsWithTamperedCiphertext() throws {
|
||||
let plaintext = "Secret".data(using: .utf8)!
|
||||
let plaintext = Data("Secret".utf8)
|
||||
let key = Data(repeating: 0x42, count: 32)
|
||||
let nonce = Data(repeating: 0x24, count: 24)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user