Skip to content

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

24.3 KB
Raw Blame
import Foundation
import Testing

struct UsageHeatmapTests {
    @Test(arguments: [UsageHeatmapMode.daily, .weekly])
    func pointerReconciliationKeepsSelectionAndFollowsAnotherCell(mode: UsageHeatmapMode) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-10-24"))
        let days = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 30, today: today)
        let original = try #require(UsageHeatmapSelection.at(column: 28, row: 3, in: days, mode: mode))
        let position = try #require(UsageHeatmap.Metrics.gridPosition(at: CGPoint(x: 426, y: 51)))
        #expect(UsageHeatmapSelection.at(column: position.column, row: position.row, in: days, mode: mode) == original)

        let next = try #require(UsageHeatmap.Metrics.gridPosition(at: CGPoint(x: 441, y: 96)))
        let updated = try #require(UsageHeatmapSelection.at(column: next.column, row: next.row, in: days, mode: mode))
        #expect(updated != original)
        #expect(updated.highlights(column: 29, row: 6, in: days, mode: mode))
    }

    @Test func pointerReconciliationRejectsOutsideAndInvalidCoordinates() {
        for point in [
            CGPoint(x: -1.5, y: 6), CGPoint(x: 6, y: -1.5),
            CGPoint(x: 448.5, y: 6), CGPoint(x: 6, y: 103.5)
        ] {
            #expect(UsageHeatmap.Metrics.gridPosition(at: point) == nil)
        }
        for coordinate in [CGFloat.nan, .infinity, -.infinity, .greatestFiniteMagnitude, -.greatestFiniteMagnitude] {
            #expect(UsageHeatmap.Metrics.gridPosition(at: CGPoint(x: coordinate, y: 6)) == nil)
            #expect(UsageHeatmap.Metrics.gridPosition(at: CGPoint(x: 6, y: coordinate)) == nil)
        }
    }

    @Test func pointerReconciliationPreservesEdgesAndMidpointSnapping() {
        for (point, column, row) in [
            (CGPoint(x: 0, y: 0), 0, 0),
            (CGPoint(x: 446, y: 101), 29, 6),
            (CGPoint(x: -1.499, y: -1.499), 0, 0),
            (CGPoint(x: 448.499, y: 103.499), 29, 6),
            (CGPoint(x: 13.499, y: 13.499), 0, 0),
            (CGPoint(x: 13.5, y: 13.5), 1, 1),
            (CGPoint(x: 433.499, y: 88.499), 28, 5),
            (CGPoint(x: 433.5, y: 88.5), 29, 6)
        ] {
            let position = UsageHeatmap.Metrics.gridPosition(at: point)
            #expect(position?.column == column && position?.row == row)
        }
    }

    @Test(arguments: [UsageHeatmapMode.daily, .weekly])
    func stationaryPointerSelectsNewDateAfterWeekChanges(mode: UsageHeatmapMode) throws {
        let before = try #require(CodexDateFormat.dayDate(from: "2026-10-24"))
        let after = try #require(CodexDateFormat.dayDate(from: "2026-10-25"))
        let oldDays = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 30, today: before)
        let newDays = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 30, today: after)
        let position = try #require(UsageHeatmap.Metrics.gridPosition(at: CGPoint(x: 426, y: 51)))
        let original = try #require(UsageHeatmapSelection.at(column: position.column, row: position.row, in: oldDays, mode: mode))
        let updated = try #require(UsageHeatmapSelection.at(column: position.column, row: position.row, in: newDays, mode: mode))

        #expect(original.dateID == (mode == .daily ? "2026-10-14" : "2026-10-11"))
        #expect(updated.dateID == (mode == .daily ? "2026-10-21" : "2026-10-18"))
        #expect(original.currentColumn(in: newDays) == position.column - 1)
        #expect(!original.highlights(column: position.column, row: position.row, in: newDays, mode: mode))
        #expect(updated.highlights(column: position.column, row: position.row, in: newDays, mode: mode))
        let period = try #require(updated.period(in: newDays, weeks: UsageHeatmapPeriod.weeks(in: newDays), mode: mode))
        #expect(period.startDate == updated.dateID)
        #expect(period.endDate == (mode == .daily ? "2026-10-21" : "2026-10-24"))
    }

    @Test(arguments: ["2026-10-18", "2026-10-20", "2026-10-24"])
    func currentWeekAlwaysHasSevenSelectableRowsWhileDailyFutureStaysEmpty(todayKey: String) throws {
        let today = try #require(CodexDateFormat.dayDate(from: todayKey))
        let days = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 2, today: today)
        let weeks = UsageHeatmapPeriod.weeks(in: days)
        let week = try #require(weeks.last ?? nil)
        #expect(week.startDate == "2026-10-18")
        #expect(week.endDate == "2026-10-24")
        for row in 0 ..< CodexWeekGrid.rowCount {
            let selection = try #require(UsageHeatmapSelection.at(column: 1, row: row, in: days, mode: .weekly))
            #expect(selection.dateID == week.startDate)
            #expect(selection.period(in: days, weeks: weeks, mode: .weekly) == week)
            #expect(selection.highlights(column: 1, row: row, in: days, mode: .weekly))
            #expect(!selection.highlights(column: 0, row: row, in: days, mode: .weekly))
            let dailySelection = UsageHeatmapSelection.at(column: 1, row: row, in: days, mode: .daily)
            #expect((dailySelection != nil) == (days[7 + row] != nil))
        }
    }

    @Test func weekAggregatesAllMetricsAndWeightsCacheHitRateByInputTokens() throws {
        let first = day(
            "2026-10-18",
            tokens: 100,
            count: 2,
            models: ["model-a": 5, "model-b": 4],
            usage: usage(input: 100, cached: 80, written: 10, output: 20, reasoning: 5)
        )
        let second = day(
            "2026-10-19",
            tokens: 200,
            count: 3,
            models: ["model-c": 5, "model-b": 4],
            usage: usage(input: 900, cached: 90, written: 20, output: 80, reasoning: 15)
        )
        let week = try #require(UsageHeatmapPeriod.weeks(in: [first, second, nil, nil, nil, nil, nil]).first ?? nil)
        #expect(week.tokenState == .available(300))
        #expect(week.activityData.threadCount == 5)
        #expect(week.activityData.turnCount == 10)
        #expect(week.activityData.toolCallCount == 15)
        #expect(week.activityData.approvalRequestedCount == 20)
        #expect(week.activityData.contextCompactionCount == 25)
        #expect(week.activityData.subagentCount == 30)
        #expect(week.activityData.mostUsedModel == "model-b")
        #expect(week.tokenUsage?.inputTokens == 1000)
        #expect(week.tokenUsage?.cachedInputTokens == 170)
        #expect(week.tokenUsage?.cacheWriteInputTokens == 30)
        #expect(week.tokenUsage?.outputTokens == 100)
        #expect(week.tokenUsage?.reasoningOutputTokens == 20)
        #expect(week.tokenUsage?.totalTokens == 1100)
        #expect(week.tokenUsage?.cacheHitRate == 0.17)
        #expect(week.endDate == "2026-10-24")
    }

    @Test(arguments: [(0, 0), (1, 1), (100, 1), (101, 2), (300, 3), (301, 4), (699, 7), (700, 7), (800, 7)])
    func histogramHeightUsesWeeklyTokensRelativeToPeak(tokens: Int, expectedRows: Int) throws {
        let week = try #require(UsageHeatmapPeriod.weeks(in: [day("2026-10-18", tokens: tokens)]).first ?? nil)
        #expect(week.filledRowCount(peakTokens: 700) == expectedRows)
        #expect(week.filledRowCount(peakTokens: 0) == 0)
    }

    @Test(arguments: [0, 100])
    func currentWeekShowsAvailableUsageAndAddsTodayWhenItArrives(knownTokens: Int) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-10-20"))
        let summary = try TestFixtures.decode(UsageSummary.self, "{}")
        let buckets = [DailyUsageBucket(startDate: "2026-10-18", tokens: knownTokens)]
        let usage = CodexUsageSnapshot(summary: summary, dailyBuckets: buckets)
        let days = UsageHeatmapDay.grid(usage: usage, history: .empty, columnCount: 1, today: today)
        let selection = try #require(UsageHeatmapSelection.at(column: 0, row: 6, in: days, mode: .weekly))
        let week = try #require(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly))
        #expect(days[2]?.tokenState == .pending)
        #expect(week.tokenState == .available(knownTokens))
        #expect(week.filledRowCount(peakTokens: 700) == (knownTokens > 0 ? 1 : 0))

        let updatedUsage = CodexUsageSnapshot(summary: summary, dailyBuckets: buckets + [DailyUsageBucket(startDate: "2026-10-20", tokens: 50)])
        let updatedDays = UsageHeatmapDay.grid(usage: updatedUsage, history: .empty, columnCount: 1, today: today)
        let updatedWeek = try #require(selection.period(in: updatedDays, weeks: UsageHeatmapPeriod.weeks(in: updatedDays), mode: .weekly))
        #expect(updatedWeek.tokenState == .available(knownTokens + 50))
        #expect(updatedWeek.startDate == "2026-10-18")
        #expect(updatedWeek.endDate == "2026-10-24")
    }

    @Test func pendingDaysPreserveAvailableTokensWhileUnavailableDataStaysUnknown() throws {
        let known = day("2026-10-18", tokens: 100, usage: usage(input: 100))
        let pending = UsageHeatmapDay(startDate: "2026-10-19", tokenState: .pending, activityData: .unavailable(startDate: "2026-10-19"))
        let unavailable = UsageHeatmapDay(startDate: "2026-10-20", tokenState: .unavailable, activityData: .empty(startDate: "2026-10-20"))
        let period = try #require(UsageHeatmapPeriod.weeks(in: [known, pending]).first ?? nil)
        #expect(period.tokenState == .available(100))
        #expect(period.activityData == known.activityData)
        #expect(period.tokenUsage == known.tokenUsage)
        #expect((UsageHeatmapPeriod.weeks(in: [pending]).first ?? nil)?.tokenState == .pending)
        #expect((UsageHeatmapPeriod.weeks(in: [pending, unavailable]).first ?? nil)?.tokenState == .unavailable)
        #expect((UsageHeatmapPeriod.weeks(in: [unavailable, known]).first ?? nil)?.tokenState == .unavailable)
        #expect((UsageHeatmapPeriod.weeks(in: [unavailable]).first ?? nil)?.tokenUsage == nil)
        #expect(UsageHeatmapPeriod.weeks(in: []).isEmpty)
        #expect(UsageHeatmapPeriod.weeks(in: Array(repeating: nil, count: CodexWeekGrid.rowCount)) == [nil])
    }

    @Test(arguments: [0, 50])
    func weeklyMetricsWaitForTodayAccountUsage(todayTokens: Int) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-11-02"))
        let first = day("2026-11-01", tokens: 100, count: 2, models: ["previous": 1], usage: usage(input: 100, cached: 50, output: 10))
        let current = day("2026-11-02", tokens: todayTokens, count: 3, models: ["current": 2], usage: usage(input: 200, cached: 190, output: 20))
        var history = HistorySnapshot(activityData: [first.activityData, current.activityData])
        history.tokenUsageByDate = try [first.startDate: #require(first.tokenUsage), current.startDate: #require(current.tokenUsage)]
        let summary = try TestFixtures.decode(UsageSummary.self, "{}")
        let buckets = [DailyUsageBucket(startDate: first.startDate, tokens: 100)]
        let account = CodexUsageSnapshot(summary: summary, dailyBuckets: buckets)
        let days = UsageHeatmapDay.grid(usage: account, history: history, columnCount: 1, today: today)
        let selection = try #require(UsageHeatmapSelection.at(column: 0, row: 1, in: days, mode: .weekly))
        let week = try #require(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly))

        #expect(week.tokenState == .available(100))
        #expect(week.activityData == first.activityData)
        #expect(week.tokenUsage == first.tokenUsage)
        #expect(week.tokenUsage?.cacheHitRate == 0.5)
        #expect(week.startDate == "2026-11-01")
        #expect(week.endDate == "2026-11-07")
        let dailySelection = UsageHeatmapSelection(dateID: current.startDate)
        let daily = try #require(dailySelection.period(in: days, weeks: [], mode: .daily))
        #expect(daily.tokenState == .pending)
        #expect(daily.activityData == current.activityData)
        #expect(daily.tokenUsage == current.tokenUsage)

        let updatedAccount = CodexUsageSnapshot(
            summary: summary,
            dailyBuckets: buckets + [DailyUsageBucket(startDate: current.startDate, tokens: todayTokens)]
        )
        let updatedDays = UsageHeatmapDay.grid(usage: updatedAccount, history: history, columnCount: 1, today: today)
        let updatedWeek = try #require(selection.period(in: updatedDays, weeks: UsageHeatmapPeriod.weeks(in: updatedDays), mode: .weekly))
        #expect(updatedWeek.tokenState == .available(100 + todayTokens))
        #expect(updatedWeek.activityData == first.activityData.adding(current.activityData))
        #expect(updatedWeek.activityData.mostUsedModel == "current")
        #expect(try updatedWeek.tokenUsage == first.tokenUsage?.adding(#require(current.tokenUsage)))
        #expect(updatedWeek.tokenUsage?.cacheHitRate == 0.8)
    }

    @Test(arguments: [true, false])
    func weekWithoutAccountUsagePreservesMetricsOnlyInDailyView(hasDailyBuckets: Bool) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-11-01"))
        let current = day("2026-11-01", tokens: 30, count: 4, models: ["current": 1], usage: usage(input: 30))
        var history = HistorySnapshot(activityData: [current.activityData])
        history.tokenUsageByDate = try [current.startDate: #require(current.tokenUsage)]
        let summary = try TestFixtures.decode(UsageSummary.self, "{}")
        let account = CodexUsageSnapshot(summary: summary, dailyBuckets: hasDailyBuckets ? [] : nil)
        let days = UsageHeatmapDay.grid(usage: account, history: history, columnCount: 1, today: today)
        let selection = UsageHeatmapSelection(dateID: current.startDate)
        let week = try #require(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly))
        #expect(week.tokenState == (hasDailyBuckets ? .pending : .unavailable))
        #expect(week.activityData == .unavailable(startDate: current.startDate))
        #expect(week.tokenUsage == nil)
        #expect(week.endDate == "2026-11-07")
        let daily = try #require(selection.period(in: days, weeks: [], mode: .daily))
        #expect(daily.tokenState == week.tokenState)
        #expect(daily.activityData == current.activityData)
        #expect(daily.tokenUsage == current.tokenUsage)
    }

    @Test(arguments: [("2026-01-01", "2025-12-28", "2026-01-03"), ("2026-03-31", "2026-03-29", "2026-04-04")])
    func fullWeekRangeCrossesMonthAndYearBoundaries(todayKey: String, start: String, end: String) throws {
        let today = try #require(CodexDateFormat.dayDate(from: todayKey))
        let days = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 1, today: today)
        let week = try #require(UsageHeatmapPeriod.weeks(in: days).first ?? nil)
        #expect(week.startDate == start)
        #expect(week.endDate == end)
    }

    @Test func selectedWeekUsesFreshDataAndDoesNotIncludeNeighboringColumns() throws {
        let first = day("2026-10-11", tokens: 900)
        let current = day("2026-10-18", tokens: 20)
        var days: [UsageHeatmapDay?] = [first, nil, nil, nil, nil, nil, nil, current, nil, nil, nil, nil, nil, nil]
        let selection = try #require(UsageHeatmapSelection.at(column: 1, row: 6, in: days, mode: .weekly))
        #expect(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly)?.tokenState == .available(20))
        #expect(selection.highlights(column: 1, row: 6, in: days, mode: .weekly))
        days[8] = day("2026-10-19", tokens: 30)
        #expect(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly)?.tokenState == .available(50))
        #expect(selection.highlights(column: 1, row: 6, in: days, mode: .weekly))
        #expect(selection.period(in: days, weeks: [], mode: .daily)?.tokenState == .available(20))
        days.removeFirst(7)
        #expect(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: .weekly)?.tokenState == .available(50))
        #expect(selection.highlights(column: 0, row: 6, in: days, mode: .weekly))
        #expect(!selection.highlights(column: 1, row: 6, in: days, mode: .weekly))
        #expect(selection.period(in: [], weeks: [], mode: .weekly) == nil)
    }

    @Test(arguments: [UsageHeatmapMode.daily, .weekly])
    func selectionHighlightAndDetailSideFollowDateAcrossColumns(mode: UsageHeatmapMode) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-10-24"))
        var days = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: UsageHeatmap.Metrics.columnCount, today: today)
        let originalColumn = UsageHeatmap.Metrics.columnCount / 2
        let selectedRow = 3
        let selection = try #require(UsageHeatmapSelection.at(column: originalColumn, row: selectedRow, in: days, mode: mode))
        let initialColumn = try #require(selection.currentColumn(in: days))
        #expect(initialColumn == originalColumn)
        #expect(UsageHeatmap.Metrics.preferredDetailSide(for: initialColumn) == .right)
        let initialPeriod = try #require(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: mode))

        days.removeFirst(CodexWeekGrid.rowCount)

        let currentColumn = try #require(selection.currentColumn(in: days))
        #expect(currentColumn == originalColumn - 1)
        #expect(UsageHeatmapSelection.at(column: currentColumn, row: selectedRow, in: days, mode: mode) == selection)
        #expect(UsageHeatmap.Metrics.preferredDetailSide(for: currentColumn) == .left)
        #expect(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: mode) == initialPeriod)
        for row in 0 ..< CodexWeekGrid.rowCount {
            #expect(selection.highlights(column: currentColumn, row: row, in: days, mode: mode) == (mode == .weekly || row == selectedRow))
            #expect(!selection.highlights(column: originalColumn, row: row, in: days, mode: mode))
        }
    }

    @Test(arguments: [UsageHeatmapMode.daily, .weekly])
    func selectionLeavingGridHasNoHighlightOrDetailEvenWhenColumnIsReused(mode: UsageHeatmapMode) throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-10-24"))
        var days = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 2, today: today)
        let selection = try #require(UsageHeatmapSelection.at(column: 0, row: 3, in: days, mode: mode))
        #expect(selection.highlights(column: 0, row: 3, in: days, mode: mode))

        days.removeFirst(CodexWeekGrid.rowCount)

        #expect(selection.day(in: days) == nil)
        #expect(selection.currentColumn(in: days) == nil)
        #expect(selection.period(in: days, weeks: UsageHeatmapPeriod.weeks(in: days), mode: mode) == nil)
        for row in 0 ..< CodexWeekGrid.rowCount {
            #expect(!selection.highlights(column: 0, row: row, in: days, mode: mode))
        }
        #expect(selection.currentColumn(in: []) == nil)
        #expect(!selection.highlights(column: 0, row: 0, in: [], mode: mode))
    }

    @Test func overflowDoesNotPublishWrappedWeeklyTotals() throws {
        let first = day("2026-10-18", tokens: Int.max, usage: usage(input: Int64.max))
        let second = day("2026-10-19", tokens: 1, usage: usage(input: 1))
        let week = try #require(UsageHeatmapPeriod.weeks(in: [first, second]).first ?? nil)
        #expect(week.tokenState == .unavailable)
        #expect(week.tokenUsage == nil)
    }

    @Test func invalidGridPositionsCannotSelectAnotherWeek() {
        let days: [UsageHeatmapDay?] = [day("2026-10-18", tokens: 1), nil, nil, nil, nil, nil, nil]
        for mode in [UsageHeatmapMode.daily, .weekly] {
            #expect(UsageHeatmapSelection.at(column: -1, row: 0, in: days, mode: mode) == nil)
            #expect(UsageHeatmapSelection.at(column: 1, row: 0, in: days, mode: mode) == nil)
            #expect(UsageHeatmapSelection.at(column: 0, row: 7, in: days, mode: mode) == nil)
            #expect(UsageHeatmapSelection.at(column: 0, row: -1, in: days, mode: mode) == nil)
            #expect(UsageHeatmapSelection.at(column: 0, row: 0, in: [], mode: mode) == nil)
        }
    }

    private func day(_ date: String, tokens: Int, count: Int = 0, models: [String: Int] = [:], usage: TokenUsage? = nil) -> UsageHeatmapDay {
        UsageHeatmapDay(
            startDate: date,
            tokenState: .available(tokens),
            activityData: ActivityDataMetrics(
                startDate: date, threadCount: count, turnCount: count * 2, toolCallCount: count * 3,
                approvalRequestedCount: count * 4, contextCompactionCount: count * 5, subagentCount: count * 6,
                modelCounts: models
            ),
            tokenUsage: usage
        )
    }

    private func usage(input: Int64, cached: Int64 = 0, written: Int64 = 0, output: Int64 = 0, reasoning: Int64 = 0) -> TokenUsage {
        TokenUsage(
            inputTokens: input,
            cachedInputTokens: cached,
            cacheWriteInputTokens: written,
            outputTokens: output,
            reasoningOutputTokens: reasoning,
            totalTokens: input + output
        )
    }

    @Test func weekGridStartsSundayAndLeavesFutureDaysBlankAcrossDST() throws {
        var calendar = Calendar(identifier: .gregorian)
        calendar.timeZone = try #require(TimeZone(identifier: "America/Los_Angeles"))
        calendar.firstWeekday = 2
        let today = try #require(calendar.date(from: DateComponents(year: 2026, month: 3, day: 10, hour: 12)))
        let grid = CodexWeekGrid.dates(columnCount: 2, today: today, calendar: calendar)
        #expect(grid.count == 14)
        #expect(grid.compactMap(\.self).count == 10)
        #expect(try calendar.component(.weekday, from: #require(grid[0])) == 1)
        #expect(try calendar.component(.weekday, from: #require(grid[7])) == 1)
        #expect(grid.suffix(4).allSatisfy { $0 == nil })
        #expect(CodexWeekGrid.dates(columnCount: 0, today: today, calendar: calendar).isEmpty)
    }

    @Test func heatmapDistinguishesTodayPendingFromUnavailableAndHistoricalZero() throws {
        let today = try #require(CodexDateFormat.dayDate(from: "2026-09-15"))
        let summary = try TestFixtures.decode(UsageSummary.self, "{}")
        let usage = CodexUsageSnapshot(summary: summary, dailyBuckets: [])
        let grid = UsageHeatmapDay.grid(usage: usage, history: .empty, columnCount: 2, today: today).compactMap(\.self)
        #expect(grid.last?.tokenState == .pending)
        #expect(grid.first?.tokenState == .available(0))
        let unavailable = UsageHeatmapDay.grid(usage: nil, history: .empty, columnCount: 2, today: today).compactMap(\.self)
        #expect(unavailable.allSatisfy { $0.tokenState == .unavailable })
    }

    @Test func heatmapSelectionReadsLatestDayDataByDate() {
        let date = "2026-09-15"
        let selection = UsageHeatmapSelection(dateID: date)
        let initial = UsageHeatmapDay(startDate: date, tokenState: .pending, activityData: .empty(startDate: date))
        let updated = UsageHeatmapDay(
            startDate: date, tokenState: .available(120), activityData: .unavailable(startDate: date), tokenUsage: .zero
        )
        let unrelated = UsageHeatmapDay(startDate: "2026-09-14", tokenState: .available(5), activityData: .empty(startDate: "2026-09-14"))
        #expect(selection.day(in: [initial, unrelated]) == initial)
        #expect(selection.day(in: [nil, unrelated, updated]) == updated)
        #expect(selection.day(in: [nil, unrelated]) == nil)
        #expect(selection.day(in: []) == nil)
    }

    @Test func partialSourcesKeepKnownValuesVisible() {
        let now = Date()
        let date = HistoryStorage.dateKey(for: now)
        var aggregate = ActivityDataAggregate(date: date)
        aggregate.turnCount = 3
        var snapshot = HistorySnapshot(activityData: [aggregate.metrics])
        snapshot.isActivityDataComplete = false
        let day = UsageHeatmapDay.grid(usage: nil, history: snapshot, columnCount: 1, today: now).compactMap(\.self).first { $0.startDate == date }
        #expect(day?.activityData.turnCount == 3)
    }

    @Test func heatmapSeparatesAccountIntensityFromLocalDailyMetrics() throws {
        let day = HistoryStorage.dateKey(for: TestFixtures.now)
        var history = HistorySnapshot.empty
        history.tokenUsageByDate = [day: TokenUsage(
            inputTokens: 100, cachedInputTokens: 20, cacheWriteInputTokens: 5,
            outputTokens: 10, reasoningOutputTokens: 2, totalTokens: 110
        )]
        let grid = UsageHeatmapDay.grid(usage: nil, history: history, columnCount: 2, today: TestFixtures.now)
        let today = try #require(grid.compactMap(\.self).first { $0.startDate == day })
        #expect(today.tokenState == .unavailable)
        #expect(today.tokenUsage?.totalTokens == 110)
        #expect(today.activityData.turnCount == 0)
    }
}