From 749f90653f845ec79ebac3b8d9e95e2029e12cb2 Mon Sep 17 00:00:00 2001 From: heyaim <223061694+heyaim@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:23:54 -0500 Subject: [PATCH] Handle unresolved metadata locations during panic wipe Cleanup now treats unresolved locations in the affected metadata stores as failures and retries the lookup on a later wipe attempt. Recovered locations remain available for subsequent saves. Memory-only behavior is unchanged. Regression tests cover failure accounting, retry and persistence after recovery. --- bitchat/Services/Board/BoardStore.swift | 18 +- bitchat/Services/Courier/CourierStore.swift | 14 +- .../Gateway/BridgeDropDedupStore.swift | 17 +- bitchat/Services/Groups/GroupStore.swift | 18 +- .../Services/NostrProcessedEventStore.swift | 12 +- bitchat/Services/PanicFileDeletion.swift | 10 +- bitchat/Sync/GossipMessageArchive.swift | 15 +- bitchatTests/ChatViewModelTests.swift | 99 ++++++++ .../Services/PanicMetadataStoreTests.swift | 220 ++++++++++++++++++ 9 files changed, 395 insertions(+), 28 deletions(-) diff --git a/bitchat/Services/Board/BoardStore.swift b/bitchat/Services/Board/BoardStore.swift index a5f346f7..15949f9b 100644 --- a/bitchat/Services/Board/BoardStore.swift +++ b/bitchat/Services/Board/BoardStore.swift @@ -91,14 +91,24 @@ final class BoardStore { private var posts: [StoredPost] = [] private var tombstones: [StoredTombstone] = [] private let queue = DispatchQueue(label: "chat.bitchat.board.store") - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? + private let persistsToDisk: Bool private let now: () -> Date /// - Parameter fileURL: Overrides the on-disk location (tests). Ignored /// when `persistsToDisk` is false. - init(persistsToDisk: Bool = true, fileURL: URL? = nil, now: @escaping () -> Date = Date.init) { + init( + persistsToDisk: Bool = true, + fileURL: URL? = nil, + now: @escaping () -> Date = Date.init, + resolveDefaultFileURL: (() -> URL?)? = nil + ) { self.now = now - self.fileURL = persistsToDisk ? (fileURL ?? Self.defaultFileURL()) : nil + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.persistsToDisk = persistsToDisk + self.fileURL = persistsToDisk ? (fileURL ?? resolver()) : nil loadFromDisk() } @@ -152,7 +162,7 @@ final class BoardStore { let removed = queue.sync { posts.removeAll() tombstones.removeAll() - let removed = PanicFileDeletion.remove(fileURL) + let removed = !persistsToDisk || PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) publishSnapshotLocked() return removed } diff --git a/bitchat/Services/Courier/CourierStore.swift b/bitchat/Services/Courier/CourierStore.swift index b6d60b8c..a6e6cc8a 100644 --- a/bitchat/Services/Courier/CourierStore.swift +++ b/bitchat/Services/Courier/CourierStore.swift @@ -121,7 +121,9 @@ final class CourierStore { private var envelopes: [StoredEnvelope] = [] private let queue = DispatchQueue(label: "chat.bitchat.courier.store") - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? + private let persistsToDisk: Bool private let now: () -> Date private let readData: (URL) throws -> Data /// A protected file can be present but unreadable during an iOS @@ -139,10 +141,14 @@ final class CourierStore { persistsToDisk: Bool = true, fileURL: URL? = nil, now: @escaping () -> Date = Date.init, - readData: @escaping (URL) throws -> Data = { try Data(contentsOf: $0) } + readData: @escaping (URL) throws -> Data = { try Data(contentsOf: $0) }, + resolveDefaultFileURL: (() -> URL?)? = nil ) { self.now = now - self.fileURL = persistsToDisk ? (fileURL ?? Self.defaultFileURL()) : nil + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.persistsToDisk = persistsToDisk + self.fileURL = persistsToDisk ? (fileURL ?? resolver()) : nil self.readData = readData loadFromDisk() #if os(iOS) @@ -421,7 +427,7 @@ final class CourierStore { let removed = queue.sync { envelopes.removeAll() diskLoadDeferred = false - let removed = PanicFileDeletion.remove(fileURL) + let removed = !persistsToDisk || PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) publishCountLocked() return removed } diff --git a/bitchat/Services/Gateway/BridgeDropDedupStore.swift b/bitchat/Services/Gateway/BridgeDropDedupStore.swift index 9ef54cf5..843fac37 100644 --- a/bitchat/Services/Gateway/BridgeDropDedupStore.swift +++ b/bitchat/Services/Gateway/BridgeDropDedupStore.swift @@ -78,12 +78,21 @@ final class BridgeDropDedupStore { var seenDropEventIDs: [String: Date] } - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? + private let persistsToDisk: Bool /// - Parameter fileURL: Overrides the on-disk location (tests). Ignored /// when `persistsToDisk` is false. - init(persistsToDisk: Bool = true, fileURL: URL? = nil) { - self.fileURL = persistsToDisk ? (fileURL ?? Self.defaultFileURL()) : nil + init( + persistsToDisk: Bool = true, + fileURL: URL? = nil, + resolveDefaultFileURL: (() -> URL?)? = nil + ) { + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.persistsToDisk = persistsToDisk + self.fileURL = persistsToDisk ? (fileURL ?? resolver()) : nil } func load() -> Snapshot { @@ -120,7 +129,7 @@ final class BridgeDropDedupStore { /// Panic wipe: forget which drops we published or handled. @discardableResult func wipe() -> Bool { - return PanicFileDeletion.remove(fileURL) + return !persistsToDisk || PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) } private static func defaultFileURL() -> URL? { diff --git a/bitchat/Services/Groups/GroupStore.swift b/bitchat/Services/Groups/GroupStore.swift index 3484dbe8..b00cf62c 100644 --- a/bitchat/Services/Groups/GroupStore.swift +++ b/bitchat/Services/Groups/GroupStore.swift @@ -22,13 +22,23 @@ final class GroupStore: ObservableObject { @Published private(set) var groups: [BitchatGroup] = [] private let keychain: KeychainManagerProtocol - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? + private let persistsToDisk: Bool /// - Parameter fileURL: Overrides the on-disk location (tests). Ignored /// when `persistsToDisk` is false. - init(keychain: KeychainManagerProtocol, persistsToDisk: Bool = true, fileURL: URL? = nil) { + init( + keychain: KeychainManagerProtocol, + persistsToDisk: Bool = true, + fileURL: URL? = nil, + resolveDefaultFileURL: (() -> URL?)? = nil + ) { self.keychain = keychain - self.fileURL = persistsToDisk ? (fileURL ?? Self.defaultFileURL()) : nil + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.persistsToDisk = persistsToDisk + self.fileURL = persistsToDisk ? (fileURL ?? resolver()) : nil loadFromDisk() } @@ -136,7 +146,7 @@ final class GroupStore: ObservableObject { _ = keychain.deleteIdentityKey(forKey: Self.keychainKey(for: group.groupID)) } groups.removeAll() - return PanicFileDeletion.remove(fileURL) + return !persistsToDisk || PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) } // MARK: - Internals diff --git a/bitchat/Services/NostrProcessedEventStore.swift b/bitchat/Services/NostrProcessedEventStore.swift index b58ec473..e9f1e58f 100644 --- a/bitchat/Services/NostrProcessedEventStore.swift +++ b/bitchat/Services/NostrProcessedEventStore.swift @@ -21,7 +21,8 @@ import Foundation /// file must also load during a locked-background restoration relaunch. /// Wiped on panic via the dedup service's clear paths. final class NostrProcessedEventStore { - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? // All file access is serialized here: appends are read-modify-write, and // overlapping debounced flushes would otherwise race and drop IDs. private let ioQueue: DispatchQueue @@ -29,9 +30,12 @@ final class NostrProcessedEventStore { /// The I/O queue must be serial to preserve append and wipe ordering. init( fileURL: URL? = nil, - ioQueue: DispatchQueue = DispatchQueue(label: "chat.bitchat.nostr-processed-events", qos: .utility) + ioQueue: DispatchQueue = DispatchQueue(label: "chat.bitchat.nostr-processed-events", qos: .utility), + resolveDefaultFileURL: (() -> URL?)? = nil ) { - self.fileURL = fileURL ?? Self.defaultFileURL() + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.fileURL = fileURL ?? resolver() self.ioQueue = ioQueue } @@ -62,7 +66,7 @@ final class NostrProcessedEventStore { @discardableResult func wipe() -> Bool { - ioQueue.sync { PanicFileDeletion.remove(fileURL) } + ioQueue.sync { PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) } } private func loadLocked() -> [String] { diff --git a/bitchat/Services/PanicFileDeletion.swift b/bitchat/Services/PanicFileDeletion.swift index 5660cdc0..398db032 100644 --- a/bitchat/Services/PanicFileDeletion.swift +++ b/bitchat/Services/PanicFileDeletion.swift @@ -9,10 +9,16 @@ import BitLogger import Foundation -/// Missing backing files are already erased; other removal errors keep panic pending. +/// Missing files succeed; unresolved persistent locations and removal errors fail. enum PanicFileDeletion { + static func remove(_ fileURL: inout URL?, resolvingWith resolve: () -> URL?) -> Bool { + // Retry a failed lookup and retain the recovered location for later persistence. + if fileURL == nil { fileURL = resolve() } + return remove(fileURL) + } + static func remove(_ fileURL: URL?) -> Bool { - guard let fileURL else { return true } + guard let fileURL else { return false } do { try FileManager.default.removeItem(at: fileURL) return true diff --git a/bitchat/Sync/GossipMessageArchive.swift b/bitchat/Sync/GossipMessageArchive.swift index 013dfc8f..49cb616d 100644 --- a/bitchat/Sync/GossipMessageArchive.swift +++ b/bitchat/Sync/GossipMessageArchive.swift @@ -18,10 +18,13 @@ import Foundation /// range — so file protection (no additional sealing) is the right at-rest /// posture. Wiped on panic. final class GossipMessageArchive { - private let fileURL: URL? + private var fileURL: URL? + private let resolveDefaultFileURL: () -> URL? - init(fileURL: URL? = nil) { - self.fileURL = fileURL ?? Self.defaultFileURL() + init(fileURL: URL? = nil, resolveDefaultFileURL: (() -> URL?)? = nil) { + let resolver = resolveDefaultFileURL ?? Self.defaultFileURL + self.resolveDefaultFileURL = resolver + self.fileURL = fileURL ?? resolver() } /// Raw binary packets, decoded and freshness-filtered by the caller. @@ -58,13 +61,13 @@ final class GossipMessageArchive { @discardableResult func wipe() -> Bool { - return PanicFileDeletion.remove(fileURL) + return PanicFileDeletion.remove(&fileURL, resolvingWith: resolveDefaultFileURL) } /// Panic-wipe hook for callers that don't hold the live instance. @discardableResult - static func wipeDefault() -> Bool { - GossipMessageArchive().wipe() + static func wipeDefault(resolveDefaultFileURL: (() -> URL?)? = nil) -> Bool { + GossipMessageArchive(resolveDefaultFileURL: resolveDefaultFileURL).wipe() } private static func defaultFileURL() -> URL? { diff --git a/bitchatTests/ChatViewModelTests.swift b/bitchatTests/ChatViewModelTests.swift index 7c9f3339..8a14f6b8 100644 --- a/bitchatTests/ChatViewModelTests.swift +++ b/bitchatTests/ChatViewModelTests.swift @@ -2214,6 +2214,105 @@ struct ChatViewModelPanicTests { #expect(viewModel.networkActivationAllowed) } + @Test(arguments: 0..<6) @MainActor + func unresolvedMetadataLocationKeepsPanicPendingUntilRetry(_ failedStore: Int) throws { + let names = ["courier", "bridge", "gossip", "groups", "board", "events"] + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let files = names.map { root.appendingPathComponent("\($0).json") } + let sibling = root.appendingPathComponent("keep.txt") + let bytes = Data("SYNTHETIC_UNRESOLVED_METADATA".utf8) + let siblingBytes = Data("KEEP".utf8) + var denyLookup = true + var lookups = Array(repeating: 0, count: names.count) + func resolve(_ index: Int) -> URL? { + lookups[index] += 1 + return denyLookup && index == failedStore ? nil : files[index] + } + let keychain = MockKeychain() + let courier = CourierStore(resolveDefaultFileURL: { resolve(0) }) + let bridge = BridgeDropDedupStore(resolveDefaultFileURL: { resolve(1) }) + let gossip = GossipMessageArchive(resolveDefaultFileURL: { resolve(2) }) + let groups = GroupStore(keychain: keychain, resolveDefaultFileURL: { resolve(3) }) + let board = BoardStore(resolveDefaultFileURL: { resolve(4) }) + let events = NostrProcessedEventStore(resolveDefaultFileURL: { resolve(5) }) + let bridgeService = BridgeCourierService(dedupStore: bridge) + let deduplicationService = MessageDeduplicationService(nostrEventStore: events) + let wipes: [() -> Bool] = [ + { courier.wipe() }, { bridgeService.wipe() }, { gossip.wipe() }, + { groups.wipe() }, { board.wipe() }, { deduplicationService.clearAll() } + ] + // File removal does not depend on decoding; seed after constructing the stores. + for file in files { try bytes.write(to: file) } + try siblingBytes.write(to: sibling) + var attempts: [String] = [] + func wipe(_ index: Int) -> Bool { + attempts.append(names[index]) + return wipes[index]() + } + let metadata = PanicMetadataWipeOperations( + wipeCourier: { wipe(0) }, wipeBridge: { wipe(1) }, + wipeGossip: { wipe(2) }, wipeGroups: { wipe(3) }, + wipeBoard: { wipe(4) }, wipeEvents: { wipe(5) } + ) + var pending = false + var mediaAttempts = 0 + var completionOrder: [String] = [] + let recovery = PanicRecoveryOperations( + isPending: { pending }, + begin: { + pending = true + return PanicRecoveryIntent(fileMarkerEstablished: true, externalMarkerEstablished: true) + }, + wipeMedia: { _ in mediaAttempts += 1 }, + complete: { completionOrder.append("complete"); pending = false } + ) + let lifecycle = PanicNetworkLifecycle(stop: {}, restart: { + #expect(!pending, "Recovery must complete before service restart") + completionOrder.append("restart") + }) + let (viewModel, transport) = makeTestableViewModel( + keychain: keychain, + panicRecoveryOperations: recovery, + panicNetworkLifecycle: lifecycle, + panicMetadataWipeOperations: metadata + ) + let starts = transport.startServicesCallCount + #expect(keychain.saveIdentityKey(Data("SYNTHETIC_KEY".utf8), forKey: "panic-url-resolution-test")) + + #expect(!viewModel.panicClearAllData(), "An unresolved persistent location must keep panic incomplete") + #expect(attempts == names, "A failed lookup must not skip other metadata stores") + #expect(keychain.deleteAllCallCount == 1) + #expect(keychain.getIdentityKey(forKey: "panic-url-resolution-test") == nil) + #expect(mediaAttempts == 1) + #expect(pending) + #expect(completionOrder.isEmpty, "An unresolved store must not complete recovery or restart services") + #expect(transport.startServicesCallCount == starts) + #expect(!viewModel.networkActivationAllowed) + #expect(try Data(contentsOf: files[failedStore]) == bytes) + for index in names.indices where index != failedStore { + #expect(!fm.fileExists(atPath: files[index].path), "Other metadata stores must still be deleted") + } + #expect(try Data(contentsOf: sibling) == siblingBytes) + + let failedLookups = lookups[failedStore] + denyLookup = false + attempts.removeAll() + #expect(viewModel.panicClearAllData(), "Retry must resolve the location and finish cleanup") + #expect(lookups[failedStore] > failedLookups, "Retry must attempt the failed lookup again") + #expect(attempts == names) + #expect(keychain.deleteAllCallCount == 2) + #expect(mediaAttempts == 2) + #expect(!pending) + #expect(completionOrder == ["complete", "restart"]) + #expect(transport.startServicesCallCount == starts + 1) + #expect(viewModel.networkActivationAllowed) + for file in files { #expect(!fm.fileExists(atPath: file.path)) } + #expect(try Data(contentsOf: sibling) == siblingBytes) + } + @Test @MainActor func metadataFailureDuringBootstrapKeepsIntentForRetry() { let names = ["courier", "bridge", "gossip", "groups", "board", "events"] diff --git a/bitchatTests/Services/PanicMetadataStoreTests.swift b/bitchatTests/Services/PanicMetadataStoreTests.swift index fd37d9b8..19773edf 100644 --- a/bitchatTests/Services/PanicMetadataStoreTests.swift +++ b/bitchatTests/Services/PanicMetadataStoreTests.swift @@ -1,5 +1,6 @@ import BitFoundation import Foundation +import CryptoKit import Testing #if canImport(Darwin) import Darwin @@ -57,6 +58,225 @@ struct PanicMetadataStoreTests { #expect(wipe(), "An absent metadata file must be harmless") } + private func makeWipe( + _ store: Store, + fileURL: URL? = nil, + persistsToDisk: Bool = true, + resolve: @escaping () -> URL? + ) -> () -> Bool { + switch store { + case .groups: + let owner = GroupStore(keychain: MockKeychain(), persistsToDisk: persistsToDisk, + fileURL: fileURL, resolveDefaultFileURL: resolve) + return { owner.wipe() } + case .board: + let owner = BoardStore(persistsToDisk: persistsToDisk, fileURL: fileURL, + resolveDefaultFileURL: resolve) + return { owner.wipe() } + case .courier: + let owner = CourierStore(persistsToDisk: persistsToDisk, fileURL: fileURL, + resolveDefaultFileURL: resolve) + return { owner.wipe() } + case .gossip: + let owner = GossipMessageArchive(fileURL: fileURL, resolveDefaultFileURL: resolve) + return { owner.wipe() } + case .bridge: + let owner = BridgeDropDedupStore(persistsToDisk: persistsToDisk, fileURL: fileURL, + resolveDefaultFileURL: resolve) + return { owner.wipe() } + case .events: + let owner = NostrProcessedEventStore(fileURL: fileURL, resolveDefaultFileURL: resolve) + return { owner.wipe() } + } + } + + @Test(arguments: Store.allCases) + func unresolvedLocationFailsAndSameOwnerRetries(_ store: Store) throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let file = root.appendingPathComponent("metadata.json") + let sibling = root.appendingPathComponent("keep.txt") + let bytes = Data("SYNTHETIC_UNRESOLVED_METADATA".utf8) + try bytes.write(to: file) + try Data("KEEP".utf8).write(to: sibling) + var resolvedURL: URL? + var lookups = 0 + let wipe = makeWipe(store) { lookups += 1; return resolvedURL } + #expect(!wipe(), "An unresolved persistent location must not count as deleted") + #expect(try Data(contentsOf: file) == bytes) + let failedLookups = lookups + resolvedURL = file + #expect(wipe(), "The same store must retry a failed location lookup") + #expect(lookups > failedLookups) + #expect(!fm.fileExists(atPath: file.path), "Recovered lookup must delete the retained metadata") + #expect(try Data(contentsOf: sibling) == Data("KEEP".utf8)) + let recoveredLookups = lookups + resolvedURL = nil + #expect(wipe(), "A recovered, now absent location must remain harmless") + #expect(lookups == recoveredLookups, "A recovered location must be retained") + } + + @Test(arguments: Store.allCases) + func explicitLocationBypassesDefaultLookup(_ store: Store) throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let file = root.appendingPathComponent("metadata.json") + var lookups = 0 + let wipe = makeWipe(store, fileURL: file) { lookups += 1; return nil } + try Data("SYNTHETIC_EXPLICIT_METADATA".utf8).write(to: file) + #expect(wipe()) + #expect(!fm.fileExists(atPath: file.path)) + #expect(wipe(), "An explicitly located missing file must be harmless") + #expect(lookups == 0, "Explicit locations must bypass default lookup") + } + + @Test(arguments: [Store.groups, .board, .courier, .bridge]) + func memoryOnlyStoreNeitherResolvesNorDeletes(_ store: Store) throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let file = root.appendingPathComponent("keep.json") + let bytes = Data("SYNTHETIC_UNOWNED_FILE".utf8) + try bytes.write(to: file) + var lookups = 0 + let wipe = makeWipe(store, fileURL: file, persistsToDisk: false) { lookups += 1; return file } + #expect(wipe(), "An intentionally memory-only store has no persistent cleanup") + #expect(fm.fileExists(atPath: file.path), "Memory-only cleanup must preserve supplied files") + if fm.fileExists(atPath: file.path) { #expect(try Data(contentsOf: file) == bytes) } + let wipeWithoutOverride = makeWipe(store, persistsToDisk: false) { lookups += 1; return file } + #expect(wipeWithoutOverride()) + #expect(lookups == 0, "Memory-only stores must not resolve a persistent location") + #expect(fm.fileExists(atPath: file.path)) + if fm.fileExists(atPath: file.path) { #expect(try Data(contentsOf: file) == bytes) } + } + + @Test + func defaultGossipWipeReportsUnresolvedLocationAndRetries() throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let file = root.appendingPathComponent("archive.json") + let sibling = root.appendingPathComponent("keep.txt") + let bytes = Data("SYNTHETIC_DEFAULT_ARCHIVE".utf8) + try bytes.write(to: file) + try Data("KEEP".utf8).write(to: sibling) + #expect(!GossipMessageArchive.wipeDefault(resolveDefaultFileURL: { nil }), + "Default archive cleanup must report failed lookup") + #expect(try Data(contentsOf: file) == bytes) + #expect(GossipMessageArchive.wipeDefault(resolveDefaultFileURL: { file })) + #expect(!fm.fileExists(atPath: file.path)) + #expect(try Data(contentsOf: sibling) == Data("KEEP".utf8)) + #expect(GossipMessageArchive.wipeDefault(resolveDefaultFileURL: { file })) + } + + @Test(arguments: Store.allCases) + func recoveredLocationSupportsSameOwnerPersistence(_ store: Store) throws { + let fm = FileManager.default + let root = fm.temporaryDirectory.appendingPathComponent(UUID().uuidString) + try fm.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? fm.removeItem(at: root) } + let file = root.appendingPathComponent("metadata.json") + var resolvedURL: URL? + let resolve = { resolvedURL } + let wipe: () -> Bool + let saveAndReload: () throws -> Void + let now = Date(timeIntervalSince1970: 1_750_000_000) + switch store { + case .groups: + let keychain = MockKeychain() + let owner = GroupStore(keychain: keychain, resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + let member = GroupMember(fingerprint: Data(repeating: 1, count: 32).hexEncodedString(), + signingKey: Data(repeating: 2, count: 32), nickname: "synthetic") + let group = try #require(owner.createGroup(named: "synthetic", creator: member)) + let reloaded = GroupStore(keychain: keychain, fileURL: file) + #expect(reloaded.group(withID: group.groupID) == group) + } + case .board: + let owner = BoardStore(now: { now }, resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + let author = Curve25519.Signing.PrivateKey() + let postID = Data(repeating: 3, count: 16) + let created = UInt64(now.timeIntervalSince1970 * 1000) + let expires = created + 3_600_000 + let key = author.publicKey.rawRepresentation + let signingBytes = BoardPostPacket.signingBytes( + postID: postID, geohash: "9q8yy", content: "synthetic", authorSigningKey: key, + authorNickname: "synthetic", createdAt: created, expiresAt: expires, flags: 0) + let post = BoardPostPacket( + postID: postID, geohash: "9q8yy", content: "synthetic", authorSigningKey: key, + authorNickname: "synthetic", createdAt: created, expiresAt: expires, flags: 0, + signature: try author.signature(for: signingBytes)) + let wire = BoardWire.post(post) + let packet = BitchatPacket(type: MessageType.boardPost.rawValue, + senderID: Data(repeating: 4, count: 8), recipientID: nil, + timestamp: created, payload: wire.encode(), signature: nil, ttl: 1) + #expect(owner.ingest(wire, packet: packet) == .accepted) + let reloaded = BoardStore(fileURL: file, now: { now }) + #expect(reloaded.posts(forGeohash: "9q8yy").map(\.postID) == [postID]) + } + case .courier: + let owner = CourierStore(now: { now }, resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + let recipient = Data(repeating: 5, count: 32) + let envelope = CourierEnvelope( + recipientTag: CourierEnvelope.recipientTag( + noiseStaticKey: recipient, epochDay: CourierEnvelope.epochDay(for: now)), + expiry: UInt64((now.timeIntervalSince1970 + 3600) * 1000), + ciphertext: Data(repeating: 6, count: 96)) + #expect(owner.deposit(envelope, from: Data(repeating: 7, count: 32))) + let reloaded = CourierStore(fileURL: file, now: { now }) + #expect(reloaded.takeEnvelopes(for: recipient) == [envelope]) + } + case .gossip: + let owner = GossipMessageArchive(resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + let packet = BitchatPacket(type: MessageType.message.rawValue, + senderID: Data(repeating: 8, count: 8), recipientID: nil, + timestamp: UInt64(now.timeIntervalSince1970 * 1000), + payload: Data("SYNTHETIC_PUBLIC_PACKET".utf8), signature: nil, ttl: 1) + let encoded = try #require(packet.toBinaryData(padding: false)) + owner.save([encoded]) + #expect(GossipMessageArchive(fileURL: file).load() == [encoded]) + } + case .bridge: + let owner = BridgeDropDedupStore(resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + owner.save(BridgeDropDedupStore.Snapshot( + publishedDropKeys: ["synthetic-drop": now], seenDropEventIDs: ["synthetic-event": now])) + let reloaded = BridgeDropDedupStore(fileURL: file).load() + #expect(reloaded.publishedDropKeys == ["synthetic-drop": now]) + #expect(reloaded.seenDropEventIDs == ["synthetic-event": now]) + } + case .events: + let owner = NostrProcessedEventStore(resolveDefaultFileURL: resolve) + wipe = { owner.wipe() } + saveAndReload = { + let eventID = String(repeating: "a", count: 64) + owner.append([eventID], cap: 10) + // load fences the serial append before a fresh owner reads the file. + #expect(owner.load() == [eventID]) + #expect(NostrProcessedEventStore(fileURL: file).load() == [eventID]) + } + } + #expect(!wipe()) + resolvedURL = file + #expect(wipe()) + resolvedURL = nil + try saveAndReload() + } + @Test(arguments: [false, true]) func panicRetirementPreventsPersistenceAndOrdinaryStopPreservesIt(_ retire: Bool) throws { let fm = FileManager.default