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.
This commit is contained in:
heyaim 2026-10-30 19:23:54 -05:00
parent c97cb0c2f9
commit 749f90653f
9 changed files with 395 additions and 28 deletions

View File

@ -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
}

View File

@ -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
}

View File

@ -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? {

View File

@ -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

View File

@ -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] {

View File

@ -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

View File

@ -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? {

View File

@ -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"]

View File

@ -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