Skip to content

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

5.9 KB
Raw Blame
import Foundation
import Testing

@Suite(.tags(.integration))
struct AppServerEventStorageTests {
    private let now = TestFixtures.now

    @Test func activityDataStorageSeparatesProtocolContextFromBusinessFields() throws {
        var event = TestFixtures.event(.toolStarted, thread: "root", turn: "child-turn", agentThreadID: "child", origin: .auxiliary)
        event.context = ActivityDataContext(
            method: "item/started", threadID: "child", turnID: "child-turn",
            parentThreadID: "parent", rootThreadID: "root", rootTurnID: "root-turn", itemID: "item",
            itemType: "commandExecution", itemStatus: "inProgress", agentThreadID: "child",
            itemKind: "started", requestID: "request", turnStatus: .running,
            turnStartedAt: now, turnCompletedAt: now.addingTimeInterval(1), duration: 1
        )
        let data = try AppServerEventRecord(activityData: event, recordedAt: now).jsonLineData()
        let record = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
        #expect(Set(record.keys) == ["schemaVersion", "recordedAt", "context", "activityData"])
        #expect(record["kind"] == nil)
        let context = try #require(record["context"] as? [String: Any])
        #expect(Set(context.keys) == [
            "method", "threadID", "turnID", "parentThreadID", "rootThreadID",
            "rootTurnID", "itemID", "itemType", "itemStatus", "agentThreadID",
            "itemKind", "requestID", "turnStatus", "turnStartedAt", "turnCompletedAt", "duration"
        ])
        #expect(context["itemKind"] as? String == "started")
        #expect(context["duration"] as? Double == 1)
        #expect(context["turnStartedAt"] as? Double == now.timeIntervalSince1970 * 1000)
        let payload = try #require(record["activityData"] as? [String: Any])
        #expect(Set(payload.keys) == [
            "timestamp", "name", "origin", "cwd", "toolName", "model", "effort",
            "threadID", "turnID", "agentThreadID"
        ])
        let decoded = try AppServerEventRecord.decode(from: data)
        #expect(decoded.activityData == event)
        #expect(decoded.context?.threadID == "child")
        #expect(decoded.activityData?.threadID == "root")
        let text = try #require(String(bytes: data, encoding: .utf8))
        #expect(text.contains("toolStarted"))
        #expect(!text.contains("PreToolUse"))
        #expect(!text.contains("commandLine"))
    }

    @Test func unsupportedVersionAndMixedPayloadAreRejected() throws {
        let observation = TestFixtures.tokenUsageObservation(at: now, tokenUsage: .zero)
        let valid = try #require(String(bytes: AppServerEventRecord(tokenUsage: observation, recordedAt: now).jsonLineData(), encoding: .utf8))
        let future = valid.replacingOccurrences(of: "\"schemaVersion\":1", with: "\"schemaVersion\":99")
        let mixed = valid.replacingOccurrences(of: "\"schemaVersion\":1", with: "\"schemaVersion\":1,\"activityData\":{}")
        for text in [future, mixed] {
            #expect(throws: (any Error).self) { try AppServerEventRecord.decode(from: Data(text.utf8)) }
        }
    }

    @Test func tokenUsageStorageUsesTokenUsageWithoutDuplicatingKind() throws {
        let observation = TestFixtures.tokenUsageObservation(at: now, tokenUsage: .zero)
        let record = AppServerEventRecord(tokenUsage: observation, recordedAt: now)
        let data = try record.jsonLineData()
        let object = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
        #expect(Set(object.keys) == ["schemaVersion", "recordedAt", "tokenUsage"])
        #expect(record.kind.rawValue == "tokenUsage")
        #expect(try AppServerEventRecord.decode(from: data).tokenUsage == observation)
    }

    @Test func timestampsUseIntegerMillisecondsAcrossJournalAndSyncCache() throws {
        let timestamp = now.addingTimeInterval(0.1234567)
        let expected = Int64(now.timeIntervalSince1970 * 1000) + 123
        var event = TestFixtures.event(.turnStarted)
        event.context = ActivityDataContext(
            method: "turn/started", threadID: "thread", turnStartedAt: timestamp,
            turnCompletedAt: timestamp, duration: 0.4567
        )
        let data = try AppServerEventRecord(activityData: event, recordedAt: timestamp).jsonLineData()
        let text = try #require(String(data: data, encoding: .utf8))
        #expect(text.contains("\"recordedAt\":\(expected),"))
        #expect(text.contains("\"turnStartedAt\":\(expected)}"))
        let decoded = try AppServerEventRecord.decode(from: data)
        #expect(decoded.recordedAt == Date(timeIntervalSince1970: Double(expected) / 1000))
        #expect(decoded.context?.duration == 0.4567)

        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let url = directory.url.appendingPathComponent("cache.json")
        let record = try ActivityDataSyncRecord(
            deviceID: "device", activityData: ActivityDataAggregate(date: "2026-09-15").syncedAggregate,
            updatedAt: timestamp, recordName: "activityData_device_2026-09-15"
        )
        try JSONFileStorage.save(record, to: url)
        let stored = try Data(contentsOf: url)
        let object = try #require(JSONSerialization.jsonObject(with: stored) as? [String: Any])
        #expect(object["updatedAt"] as? Int64 == expected)
        #expect(object["date"] as? String == "2026-09-15")
        let restored = try JSONLines.decoder.decode(ActivityDataSyncRecord.self, from: stored)
        #expect(restored.updatedAt == decoded.recordedAt)
        #expect(try JSONLines.stableEncoder.encode(restored) == stored)

        var cache = TokenUsageFileCache<[TokenUsageObservation]>(url: directory.url.appendingPathComponent("tokenUsage.json"))
        try cache.save([TestFixtures.tokenUsageObservation(at: timestamp, tokenUsage: .zero)])
        var reopened = TokenUsageFileCache<[TokenUsageObservation]>(url: cache.url)
        #expect(try reopened.load()?.first?.observedAt == decoded.recordedAt)
    }
}