Skip to content

CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息

7.7 KB
Raw Blame
import Foundation
import SQLite3
import Testing

@Suite(.tags(.integration))
struct StorageRetentionTests {
    @Test func cacheCleanupRunsDailyAndRetriesOnlyFailedStore() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let now = Date()
        let tomorrow = try #require(Calendar.current.date(byAdding: .day, value: 1, to: now))
        let expired = HistoryStorage.retentionCutoffDate(today: now).addingTimeInterval(-86400)
        let key = HistoryStorage.dateKey(for: expired)
        let activityDataRecord = try ActivityDataSyncRecord(
            deviceID: "device", activityData: ActivityDataAggregate(date: key).syncedAggregate,
            recordName: ActivityDataSyncRecord.recordName(deviceID: "device", date: key)
        )
        let activityDataCache = try JSONLines.stableEncoder.encode(ActivityDataSyncCache(
            state: ActivityDataSyncState(deviceID: "device"), records: [activityDataRecord.id: activityDataRecord]
        ))
        let tokenUsageRecord = TokenUsageSyncRecord(deviceID: "device", date: key, tokenUsage: .zero)
        let tokenUsageCacheData = try JSONLines.stableEncoder.encode(TokenUsageSyncCache(
            state: TokenUsageSyncState(deviceID: "device"), records: [tokenUsageRecord.id: tokenUsageRecord]
        ))
        let activityDataURL = try directory.write(activityDataCache, to: "Sync/activityData.json")
        let tokenUsageURL = try directory.write(Data(#"{"schemaVersion":999}"#.utf8), to: "Sync/tokenUsage.json")
        let sync = SyncService(directoryURL: directory.url, isEnabled: { false })
        await sync.pruneLocalCaches(now: now)
        #expect(try JSONLines.decoder.decode(ActivityDataSyncCache.self, from: Data(contentsOf: activityDataURL)).records.isEmpty)
        try activityDataCache.write(to: activityDataURL)
        try tokenUsageCacheData.write(to: tokenUsageURL)
        await sync.pruneLocalCaches(now: now)
        #expect(try Data(contentsOf: activityDataURL) == activityDataCache)
        #expect(try JSONLines.decoder.decode(TokenUsageSyncCache.self, from: Data(contentsOf: tokenUsageURL)).records.isEmpty)
        try tokenUsageCacheData.write(to: tokenUsageURL)
        await sync.pruneLocalCaches(now: now)
        #expect(try Data(contentsOf: tokenUsageURL) == tokenUsageCacheData)
        _ = try ActivityDataSyncStore(directoryURL: directory.url).load()
        #expect(try Data(contentsOf: activityDataURL) == activityDataCache)
        await sync.pruneLocalCaches(now: tomorrow)
        #expect(try JSONLines.decoder.decode(ActivityDataSyncCache.self, from: Data(contentsOf: activityDataURL)).records.isEmpty)
        #expect(try JSONLines.decoder.decode(TokenUsageSyncCache.self, from: Data(contentsOf: tokenUsageURL)).records.isEmpty)
    }

    @Test(arguments: [false, true])
    func logsExpireOnReadAndReopenWithoutCapacityPressure(reopen: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let clock = RetentionClock()
        let storage = AppServerLogStore(directoryURL: directory.url, now: { clock.read() })
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let expired = storage.beginRequest(method: "expired", payload: "{}")
        let boundary = storage.beginRequest(method: "boundary", payload: "{}")
        let original = try await storage.page()
        let tomorrow = try #require(Calendar.current.date(byAdding: .day, value: 1, to: clock.read()))
        let cutoff = HistoryStorage.retentionCutoffDate(today: tomorrow)
        var database: OpaquePointer?
        #expect(sqlite3_open(directory.url.appendingPathComponent(AppServerLogStore.databaseName).path, &database) == SQLITE_OK)
        defer { sqlite3_close(database) }
        for (id, date) in [(expired, cutoff.addingTimeInterval(-1)), (boundary, cutoff)] {
            let sql = "UPDATE entries SET payload = CAST(json_set(CAST(payload AS TEXT), '$.requestedAt', \(date.timeIntervalSinceReferenceDate)) AS BLOB) WHERE id = '\(id.uuidString)'"
            #expect(sqlite3_exec(database, sql, nil, nil, nil) == SQLITE_OK)
        }
        clock.set(tomorrow)
        let reader = reopen ? AppServerLogStore(directoryURL: directory.url, now: { clock.read() }) : storage
        defer { await #expect(throws: Never.self) { try await reader.close() } }
        let page = try await reader.page()
        #expect(page.total == 1)
        #expect(page.entries.map(\.id) == [boundary])
        #expect(page.generation > original.generation)
        reader.finishRequest(expired, response: "late response")
        #expect(try await reader.page().total == 1)
    }

    @Test func disabledSyncStillPrunesBothLocalCaches() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let cutoff = HistoryStorage.retentionCutoffDate()
        let expired = cutoff.addingTimeInterval(-86400)
        let expiredKey = HistoryStorage.dateKey(for: expired)
        let retainedKey = HistoryStorage.dateKey(for: cutoff)
        let records = try [expiredKey, retainedKey].map { date in
            let daily = try TestFixtures.decode(SyncedActivityData.self, """
            {"schemaVersion":1,"aggregationVersion":1,"date":"\(date)","eventCount":1}
            """)
            return try ActivityDataSyncRecord(
                deviceID: "device", activityData: daily,
                recordName: ActivityDataSyncRecord.recordName(deviceID: "device", date: date)
            )
        }
        let cache = ActivityDataSyncCache(
            state: ActivityDataSyncState(deviceID: "device"),
            records: Dictionary(uniqueKeysWithValues: records.map { ($0.id, $0) })
        )
        _ = try directory.write(JSONLines.stableEncoder.encode(cache), to: "Sync/activityData.json")
        let days = [
            TokenUsageSyncRecord(deviceID: "device", date: expiredKey, tokenUsage: .zero),
            TokenUsageSyncRecord(deviceID: "device", date: retainedKey, tokenUsage: .zero),
            TokenUsageSyncRecord(deviceID: "other", date: retainedKey, tokenUsage: .zero)
        ]
        let tokenUsageCache = TokenUsageSyncCache(
            state: TokenUsageSyncState(deviceID: "device"), records: Dictionary(uniqueKeysWithValues: days.map { ($0.id, $0) }),
            cursor: Data("cursor".utf8)
        )
        _ = try directory.write(JSONLines.stableEncoder.encode(tokenUsageCache), to: "Sync/tokenUsage.json")
        let sync = SyncService(directoryURL: directory.url, isEnabled: { false })
        let service = HistoryService(directoryURL: directory.url, syncService: sync)
        _ = await service.loadSnapshotWithMaintenance(synchronize: false, trigger: .manual)
        let activityData = try Data(contentsOf: directory.url.appendingPathComponent("Sync/activityData.json"))
        let activityDataCache = try JSONLines.decoder.decode(ActivityDataSyncCache.self, from: activityData)
        #expect(activityDataCache.sortedRecords.map(\.date) == [retainedKey])
        #expect(activityDataCache.state.deviceID == "device")
        let tokenUsageData = try Data(contentsOf: directory.url.appendingPathComponent("Sync/tokenUsage.json"))
        let tokenUsageCacheData = try JSONLines.decoder.decode(TokenUsageSyncCache.self, from: tokenUsageData)
        #expect(Set(tokenUsageCacheData.records.keys) == ["tokenUsage_device_\(retainedKey)", "tokenUsage_other_\(retainedKey)"])
        #expect(tokenUsageCacheData.cursor == nil)
    }
}

private final nonisolated class RetentionClock: @unchecked Sendable {
    private let lock = NSLock()
    private var value = Date()

    func read() -> Date {
        lock.withLock { value }
    }

    func set(_ date: Date) {
        lock.withLock { value = date }
    }
}

extension StorageRetentionTests {}