mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-11-15 08:12:23 +00:00
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:
parent
c97cb0c2f9
commit
749f90653f
@ -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
|
||||
}
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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? {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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] {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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? {
|
||||
|
||||
@ -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"]
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user