CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
import CloudKit
import Foundation
import Synchronization
import Testing
@Suite(.tags(.integration))
struct ZoneRecoveryTests {
private static let zone = CKRecordZone.ID(zoneName: SyncCloudKit.zoneName, ownerName: CKCurrentUserDefaultName)
@Test(arguments: [CKError.Code.zoneNotFound, .userDeletedZone, .unknownItem], [false, true])
func absentZoneIsCreatedAndLocalDataIsUploaded(code: CKError.Code, wrapped: Bool) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
await database.removeZone(code: code, wrapped: wrapped)
_ = try directory.write("invalid activityData cache", to: "Sync/activityData.json")
_ = try directory.write("invalid token cache", to: "Sync/tokenUsage.json")
let service = service(database, directory)
let snapshot = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(snapshot.currentDeviceID != nil)
#expect(await database.creations == 1)
#expect(await database.recordCount("ActivityData") == 1)
#expect(await database.recordCount("TokenUsage") == 1)
#expect(try ActivityDataSyncStore(directoryURL: directory.url).load().records.count == 1)
}
@Test(arguments: [ZoneDatabase.Point.metadata, .query, .changes, .activityDataUpload, .tokenUsageUpload], [false, true])
private func deletionDuringSyncResetsBothPipelinesAndRetries(point: ZoneDatabase.Point, wrapped: Bool) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
_ = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
let previousID = ActivityDataSyncStore(directoryURL: directory.url).loadState().deviceID
if point == .query {
let store = ActivityDataSyncStore(directoryURL: directory.url)
var state = store.loadState()
state.lastPrunedDate = nil
try store.saveState(state)
}
// 保留 salt, 验证设备 ID 不变时也能恢复
await database.failOnce(at: point, wrapped: wrapped, preservingSalt: true)
let snapshot = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0, events: 3)],
localTokenUsageAggregates: [turn(0, tokens: 3)],
trigger: .manual
)
#expect(snapshot.currentDeviceID == previousID)
#expect(await database.creations == 1)
#expect(await database.recordCount("ActivityData") == 1)
#expect(await database.recordCount("TokenUsage") == 1)
#expect(snapshot.activityData.count == 1)
#expect(try cachedTokenUsageCount(directory) == 1)
#expect(try ActivityDataSyncStore(directoryURL: directory.url).load().records.count == 1)
}
@Test func peerRecreatingSameZoneInvalidatesCachedIdentityAndRecords() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
let first = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
await database.recreateByPeer()
let second = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(first.currentDeviceID != second.currentDeviceID)
#expect(second.currentDeviceID != nil)
#expect(await database.creations == 0)
#expect(await database.recordCount("ActivityData") == 1)
#expect(await database.recordCount("TokenUsage") == 1)
#expect(second.activityData.count == 1)
#expect(try cachedTokenUsageCount(directory) == 1)
}
@Test(arguments: [nil, "iCloud.app.zabrian.codexbar"] as [String?])
func switchingContainerDiscardsOldSyncState(containerIdentifier: String?) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
let first = service(database, directory)
_ = await first.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
let store = ActivityDataSyncStore(directoryURL: directory.url)
var state = store.loadState()
state.containerIdentifier = containerIdentifier
try store.saveState(state)
// 新容器已有 zone 时也必须重新上传并移除旧容器缓存
let nextDatabase = ZoneDatabase()
let next = service(nextDatabase, directory)
let snapshot = await next.snapshotFromCacheIfEnabled()
#expect(snapshot.currentDeviceID == nil)
#expect(snapshot.activityData.isEmpty)
#expect(snapshot.tokenUsageByDate?.isEmpty == true)
#expect(try store.load().records.isEmpty)
let synced = await next.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(synced.currentDeviceID != nil)
#expect(synced.activityData.count == 1)
#expect(try cachedTokenUsageCount(directory) == 1)
#expect(await nextDatabase.recordCount("ActivityData") == 1)
#expect(await nextDatabase.recordCount("TokenUsage") == 1)
#expect(store.loadState().containerIdentifier == SyncCloudKit.containerIdentifier)
}
@Test func repeatedDeletionHasBoundedRecoveryAndCanRecoverOnNextRun() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
await database.failOnce(at: .query, repeats: true)
let service = service(database, directory)
let failed = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(await database.queryCount == 2)
#expect(await database.creations == 1)
#expect(failed.currentDeviceID == nil)
#expect(try ActivityDataSyncStore(directoryURL: directory.url).load().records.isEmpty)
await database.repair()
let recovered = await service.synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(recovered.currentDeviceID != nil)
#expect(await database.creations == 2)
#expect(await database.recordCount("ActivityData") == 1)
#expect(await database.recordCount("TokenUsage") == 1)
}
@Test(arguments: [CKError.Code.networkFailure, .notAuthenticated, .permissionFailure, .quotaExceeded])
func unrelatedFailuresDoNotResetZoneOrSyncedState(code: CKError.Code) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
let before = ActivityDataSyncStore(directoryURL: directory.url).loadState()
let tokens = try Data(contentsOf: directory.url.appendingPathComponent("Sync/tokenUsage.json"))
await database.rejectChanges(code)
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(await database.creations == 0)
#expect(ActivityDataSyncStore(directoryURL: directory.url).loadState() == before)
#expect(try Data(contentsOf: directory.url.appendingPathComponent("Sync/tokenUsage.json")) == tokens)
}
@Test func switchingSyncOffDuringFailurePreventsZoneCreation() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let enabled = Mutex(true)
let database = ZoneDatabase(onFailure: { enabled.withLock { $0 = false } })
await database.removeZone()
let service = SyncService(
database: database,
directoryURL: directory.url,
isEnabled: { enabled.withLock { $0 } }
)
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(await database.creations == 0)
#expect(await database.recordCount("Metadata") == 0)
}
@Test func interruptedCacheResetRemainsRecoverableAfterRestart() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = ZoneDatabase()
await database.removeZone()
let store = ActivityDataSyncStore(directoryURL: directory.url)
try store.saveState(ActivityDataSyncState(deviceID: "stale"))
let stale = aggregate(0).syncedAggregate
let record = try ActivityDataSyncRecord(deviceID: "stale", activityData: stale, recordName: ActivityDataSyncRecord.recordName(deviceID: "stale", date: stale.date))
try store.saveFetchedRecords([record.id: record], cursor: nil)
let blocked = directory.url.appendingPathComponent("Locks/tokenUsageSyncCache.lock")
try FileManager.default.createDirectory(at: blocked, withIntermediateDirectories: true)
_ = await service(database, directory).synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], trigger: .manual)
#expect(store.loadState().deviceID == nil)
#expect(try store.load().records.isEmpty)
#expect(await database.creations == 0)
try FileManager.default.removeItem(at: blocked)
let snapshot = await service(database, directory).synchronizeIfEnabled(
localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)],
trigger: .manual
)
#expect(snapshot.currentDeviceID != nil)
#expect(await database.creations == 1)
#expect(await database.recordCount("ActivityData") == 1)
}
@Test func zoneClassificationKeepsRecordAndZoneErrorsSeparate() {
let item = CKRecord.ID(recordName: "missing", zoneID: Self.zone)
let other = CKRecordZone.ID(zoneName: "another")
func partial(_ key: AnyHashable, _ code: CKError.Code) -> CKError {
CKError(.partialFailure, userInfo: [CKPartialErrorsByItemIDKey: [key: CKError(code)]])
}
#expect(!SyncRecovery.isMissingZone(CKError(.unknownItem), zoneID: Self.zone))
#expect(SyncRecovery.isMissingZone(CKError(.unknownItem), zoneID: Self.zone, queryingZone: true))
#expect(!SyncRecovery.isMissingZone(partial(item, .unknownItem), zoneID: Self.zone, queryingZone: true))
#expect(!SyncRecovery.isMissingZone(partial(other, .userDeletedZone), zoneID: Self.zone))
#expect(SyncRecovery.isMissingZone(partial(item, .userDeletedZone), zoneID: Self.zone))
#expect(!SyncRecovery.isMissingZone(CKError(.changeTokenExpired), zoneID: Self.zone))
}
private func service(_ database: ZoneDatabase, _ directory: TestDirectory) -> SyncService {
SyncService(database: database, directoryURL: directory.url, isEnabled: { true })
}
private func aggregate(_ index: Int, events: Int = 1) -> ActivityDataAggregate {
TestFixtures.activityDataAggregate(date: HistoryStorage.dateKey(for: Date().addingTimeInterval(Double(-index) * 86400)), events: events)
}
private func turn(_ index: Int, tokens: Int = 1) -> TokenUsageAggregate {
let now = Date().addingTimeInterval(Double(-index) * 86400)
let tokenUsage = TokenUsage(
inputTokens: Int64(tokens), cachedInputTokens: 0, cacheWriteInputTokens: 0,
outputTokens: 0, reasoningOutputTokens: 0, totalTokens: Int64(tokens)
)
return TestFixtures.tokenUsageAggregate(at: now, tokenUsage: tokenUsage)
}
private func cachedTokenUsageCount(_ directory: TestDirectory) throws -> Int {
let data = try Data(contentsOf: directory.url.appendingPathComponent("Sync/tokenUsage.json"))
let json = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
return try #require(json["records"] as? [[String: Any]]).count
}
}
private actor ZoneDatabase: SyncDatabase {
enum Point: Sendable { case metadata, query, changes, activityDataUpload, tokenUsageUpload }
private var exists = true
private var stored: [CKRecord.ID: CKRecord] = [:]
private var missingCode = CKError.Code.userDeletedZone
private var wrapped = false
private var failurePoint: Point?
private var repeats = false
private var savedMetadata: CKRecord?
private var preservesSalt = false
private var changesError: CKError.Code?
private let onFailure: @Sendable () -> Void
private(set) var creations = 0
private(set) var queryCount = 0
init(onFailure: @escaping @Sendable () -> Void = {}) {
self.onFailure = onFailure
}
func recordCount(_ type: String) -> Int {
stored.values.filter { $0.recordType == type }.count
}
func removeZone(code: CKError.Code = .userDeletedZone, wrapped: Bool = false) {
exists = false
stored = [:]
missingCode = code
self.wrapped = wrapped
}
func failOnce(at point: Point, wrapped: Bool = false, preservingSalt: Bool = false, repeats: Bool = false) {
failurePoint = point
self.wrapped = wrapped
preservesSalt = preservingSalt
self.repeats = repeats
}
func repair() {
failurePoint = nil
}
func rejectChanges(_ code: CKError.Code) {
changesError = code
}
func recreateByPeer() {
let metadata = stored.values.first { $0.recordType == "Metadata" }?.copy() as? CKRecord
stored = [:]
metadata?["salt"] = Data(repeating: 7, count: 32) as CKRecordValue
if let metadata {
stored[metadata.recordID] = metadata
}
}
private func check(_ point: Point?, zone: CKRecordZone.ID, record: CKRecord.ID? = nil) throws {
if let point, failurePoint == point {
savedMetadata = preservesSalt ? stored.values.first { $0.recordType == "Metadata" } : nil
stored = [:]
exists = false
if !repeats {
failurePoint = nil
}
}
guard !exists else { return }
onFailure()
let error = CKError(missingCode)
if wrapped {
let key: AnyHashable = record.map(AnyHashable.init) ?? AnyHashable(zone)
throw CKError(.partialFailure, userInfo: [CKPartialErrorsByItemIDKey: [key: error]])
}
throw error
}
func recordZone(for id: CKRecordZone.ID) async throws -> CKRecordZone {
try check(nil, zone: id)
return CKRecordZone(zoneID: id)
}
func modifyRecordZones(saving zones: [CKRecordZone], deleting _: [CKRecordZone.ID]) async throws -> ZoneModification {
creations += 1
exists = true
if let savedMetadata {
stored[savedMetadata.recordID] = savedMetadata
}
return (Dictionary(uniqueKeysWithValues: zones.map { ($0.zoneID, .success($0)) }), [:])
}
func records(for ids: [CKRecord.ID], desiredKeys _: [CKRecord.FieldKey]?) async throws -> Records {
if let id = ids.first {
try check(id.recordName == "accountSalt" ? .metadata : nil, zone: id.zoneID, record: id)
}
return Dictionary(uniqueKeysWithValues: ids.map { id in
(id, stored[id].map { .success(copy($0)) } ?? .failure(CKError(.unknownItem)))
})
}
func modifyRecords(
saving records: [CKRecord],
deleting ids: [CKRecord.ID],
savePolicy _: CKModifyRecordsOperation.RecordSavePolicy,
atomically _: Bool
) async throws -> Modification {
if let record = records.first {
let point: Point? = record.recordType == "ActivityData" ? .activityDataUpload : record.recordType == "TokenUsage" ? .tokenUsageUpload : nil
try check(point, zone: record.recordID.zoneID, record: record.recordID)
}
for record in records {
stored[record.recordID] = copy(record)
}
for id in ids {
try check(nil, zone: id.zoneID, record: id)
stored[id] = nil
}
return (Dictionary(uniqueKeysWithValues: records.map { ($0.recordID, .success(copy($0))) }), Dictionary(uniqueKeysWithValues: ids.map { ($0, .success(())) }))
}
func records(matching query: CKQuery, inZoneWith zone: CKRecordZone.ID?, desiredKeys _: [CKRecord.FieldKey]?, resultsLimit _: Int) async throws -> QueryPage {
queryCount += 1
try check(.query, zone: zone ?? CKRecordZone.default().zoneID)
return (stored.values.filter { $0.recordType == query.recordType }.map { ($0.recordID, .success(copy($0))) }, nil)
}
func records(continuingMatchFrom _: CKQueryOperation.Cursor, desiredKeys _: [CKRecord.FieldKey]?, resultsLimit _: Int) async throws -> QueryPage {
([], nil)
}
func fetchChanges(inZoneWith zone: CKRecordZone.ID, since _: CKServerChangeToken?, resultsLimit _: Int) async throws -> SyncChanges {
if let changesError {
throw CKError(changesError)
}
try check(.changes, zone: zone)
return SyncChanges(records: stored.mapValues { .success(copy($0)) }, deletions: [], token: nil, moreComing: false)
}
private func copy(_ record: CKRecord) -> CKRecord {
record.copy() as? CKRecord ?? record
}
}