Skip to content

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

10.8 KB
Raw Blame
import Combine
import Foundation
import Testing

struct TaskGlowPreviewTests {
    private let now = TestFixtures.now

    @Test func previewRequestsDoNotChangePreferences() throws {
        let preferences = try TestPreferences()
        defer { preferences.remove() }
        let settings = TaskGlowSettings(defaults: preferences.defaults)
        var requests: [TaskGlowPreviewRequest] = []
        let subscription = settings.previewRequests.sink { requests.append($0) }
        defer { subscription.cancel() }
        settings.previewColor(for: .waiting)
        #expect(requests.isEmpty)
        settings.setEnabled(true)
        let saved = preferences.defaults.dictionaryRepresentation() as NSDictionary
        for role in TaskGlowColorRole.allCases {
            settings.previewColor(for: role)
        }
        settings.endColorPreview()
        #expect(requests == [.enabled, .color(.running), .color(.waiting), .color(.completed), .color(.terminated), .endColorPreview])
        #expect(preferences.defaults.dictionaryRepresentation() as NSDictionary == saved)
    }

    @Test func completionDuringPreviewGetsFullDurationAfterReturnTransition() {
        var state = enabledState()
        state.suspend(now: now)
        let completion = completed(at: 2)
        update(&state, snapshot: completion, at: 2)
        state.refresh(now: time(60), terminalDuration: 15)
        #expect(state.state == .completed)
        #expect(state.isSuspended)
        state.resume(now: time(60.4))
        state.refresh(now: time(60), terminalDuration: 15)
        #expect(state.terminal?.startedAt == time(60.4))
        #expect(state.terminal?.expiresAt == time(75.4))
        #expect(completion.latestTerminalEvent?.endedAt == time(2))
        state.refresh(now: time(75.4), terminalDuration: 15)
        #expect(state.state == .hidden)
    }

    @Test func interruptedCompletionKeepsOnlyRemainingTimeAcrossRepeatedPreviews() {
        var state = enabledState(snapshot: completed(at: 0))
        state.suspend(now: time(5))
        state.suspend(now: time(8))
        state.refresh(now: time(20), terminalDuration: 15)
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.terminal?.expiresAt == time(30))
        state.suspend(now: time(22))
        state.resume(now: time(40))
        state.refresh(now: time(40), terminalDuration: 15)
        #expect(state.terminal?.expiresAt == time(48))
        state.refresh(now: time(48), terminalDuration: 15)
        #expect(state.state == .hidden)
    }

    @Test func previewDuringReturnTransitionDoesNotAddUnshownTime() {
        var state = enabledState(snapshot: completed(at: 0))
        state.suspend(now: time(5))
        state.resume(now: time(10.4))
        state.refresh(now: time(10), terminalDuration: 15)
        state.suspend(now: time(10.1))
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.terminal?.expiresAt == time(30))
    }

    @Test func expiredCompletionDoesNotReviveAfterPreview() {
        var state = enabledState(snapshot: completed(at: 0))
        state.refresh(now: time(20), terminalDuration: 15)
        state.suspend(now: time(20))
        state.resume(now: time(60))
        state.refresh(now: time(60), terminalDuration: 15)
        #expect(state.state == .hidden)
    }

    @Test func newTerminationDuringInterruptedReturnGetsFullTime() {
        var state = enabledState(snapshot: completed(at: 0))
        state.suspend(now: time(5))
        state.resume(now: time(10.4))
        state.refresh(now: time(10), terminalDuration: 15)
        state.suspend(now: time(10.1))
        let termination = ActivityTermination(
            id: UUID(), projectName: nil, modelName: nil,
            effort: nil, terminatedAt: time(10.2), duration: 60, threadID: "terminated-thread"
        )
        let snapshot = ActivitySnapshot(
            waitingTasks: [], runningTasks: [], recentCompletions: completed(at: 0).recentCompletions,
            recentTerminations: [termination]
        )
        update(&state, snapshot: snapshot, at: 10.2)
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.state == .terminated)
        #expect(state.terminal?.eventID == termination.id)
        #expect(state.terminal?.expiresAt == time(35))
        state.refresh(now: time(35), terminalDuration: 15)
        #expect(state.state == .hidden)
    }

    @Test func onlyLatestTerminalStateSurvivesPreview() {
        var state = enabledState()
        state.suspend(now: now)
        update(&state, snapshot: completed(at: 2), at: 2)
        let latest = completed(at: 5)
        update(&state, snapshot: latest, at: 5)
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.terminal?.eventID == latest.latestTerminalEvent?.id)
        #expect(state.terminal?.expiresAt == time(35))
        state.refresh(now: time(35), terminalDuration: 15)
        #expect(state.state == .hidden)
    }

    @Test func latestWaitingTaskReplacesCompletionDuringPreview() {
        var state = enabledState()
        state.suspend(now: now)
        update(&state, snapshot: completed(at: 2), at: 2)
        update(&state, snapshot: active(waiting: true), at: 3)
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.state == .waiting)
        #expect(state.terminal == nil)
    }

    @Test func concurrentBriefCompletionGetsFullTimeAfterPreview() throws {
        var state = enabledState(snapshot: active())
        state.suspend(now: time(1))
        let event = try #require(completed(at: 2).latestTerminalEvent)
        state.update(snapshot: active(), terminalEvents: [event], isEnabled: true, acceptsBriefEvents: true, now: time(2))
        state.refresh(now: time(20), terminalDuration: 15)
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.state == .completed)
        #expect(state.terminal?.expiresAt == time(23))
        state.refresh(now: time(23), terminalDuration: 15)
        #expect(state.state == .running)
    }

    @Test func interruptedBriefCompletionResumesRemainingTime() throws {
        var state = enabledState(snapshot: active())
        let event = try #require(completed(at: 1).latestTerminalEvent)
        state.update(snapshot: active(), terminalEvents: [event], isEnabled: true, acceptsBriefEvents: true, now: time(1))
        state.refresh(now: time(1), terminalDuration: 15)
        state.suspend(now: time(2))
        state.resume(now: time(20))
        state.refresh(now: time(20), terminalDuration: 15)
        #expect(state.terminal?.expiresAt == time(22))
        state.refresh(now: time(22), terminalDuration: 15)
        #expect(state.state == .running)
    }

    @Test func disablingDropsSuspensionAndSleepDoesNotExtendIt() {
        var state = enabledState(snapshot: completed(at: 0))
        state.suspend(now: time(5))
        state.resume(now: time(10))
        state.refresh(now: time(60), terminalDuration: 15)
        #expect(state.state == .hidden)
        state.suspend(now: time(60))
        state.update(snapshot: .empty, terminalEvents: [], isEnabled: false, acceptsBriefEvents: false, now: time(60))
        state.refresh(now: time(60), terminalDuration: 15)
        #expect(!state.isSuspended)
        #expect(state.state == .hidden)
    }

    @Test(arguments: TaskGlowColorRole.allCases)
    func previewUsesStateAnimationAndIndependentPlaybackIdentity(_ role: TaskGlowColorRole) {
        let playback = TaskGlowPlayback(startsAt: time(0.4), mediaStart: 100.4)
        let preview = TaskGlowPreviewPresentation(role: role, isColorPreview: true, playback: playback, speed: .standard)
        let next = TaskGlowPreviewPresentation(
            role: role, isColorPreview: true,
            playback: TaskGlowPlayback(startsAt: time(1), mediaStart: 101), speed: .standard
        )
        #expect(preview.playback.id != next.playback.id)
        switch role {
        case .running:
            #expect(preview.state == .running)
            #expect(preview.expiresAt == time(3.1))
        case .waiting:
            #expect(preview.state == .waiting)
            #expect(preview.expiresAt == time(3.75))
        case .completed, .terminated:
            #expect(preview.state == (role == .completed ? .completed : .terminated))
            #expect(preview.expiresAt == time(3.4))
            #expect(preview.terminal?.startedAt == time(0.4))
            #expect(preview.terminal?.eventID == playback.id)
        }
    }

    @Test(arguments: [TaskGlowColorRole.running, .waiting])
    func changingSpeedPreservesCycleProgress(_ role: TaskGlowColorRole) {
        var preview = TaskGlowPreviewPresentation(
            role: role, isColorPreview: true,
            playback: TaskGlowPlayback(startsAt: now, mediaStart: 100), speed: .standard
        )
        let entrance = role == .waiting ? TaskGlowAnimationTiming.expansionDuration : 0
        let duration = preview.expiresAt.timeIntervalSince(now) - entrance
        let halfway = time(entrance + duration / 2)
        preview.setAnimationSpeed(.slow, now: halfway)
        #expect(abs(preview.expiresAt.timeIntervalSince(halfway) - duration * 0.75) < 0.00001)
        #expect(abs(preview.playback.mediaStart - 100 - preview.playback.startsAt.timeIntervalSince(now)) < 0.00001)
    }

    private func enabledState(snapshot: ActivitySnapshot = .empty) -> TaskGlowPresentationState {
        var state = TaskGlowPresentationState()
        update(&state, snapshot: snapshot, at: 0)
        state.refresh(now: now, terminalDuration: 15)
        return state
    }

    private func update(_ state: inout TaskGlowPresentationState, snapshot: ActivitySnapshot, at seconds: TimeInterval) {
        state.update(snapshot: snapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: time(seconds))
    }

    private func time(_ seconds: TimeInterval) -> Date {
        now.addingTimeInterval(seconds)
    }

    private func completed(at seconds: TimeInterval) -> ActivitySnapshot {
        let completion = ActivityCompletion(
            id: UUID(), projectName: nil, modelName: nil,
            effort: nil, completedAt: time(seconds), duration: 60, threadID: "completed-thread"
        )
        return ActivitySnapshot(waitingTasks: [], runningTasks: [], recentCompletions: [completion], recentTerminations: [])
    }

    private func active(waiting: Bool = false) -> ActivitySnapshot {
        let task = ActivityTaskSnapshot(
            id: UUID(), projectName: nil,
            modelName: nil, effort: nil, startedAt: now,
            stateChangedAt: now, activeSubagentCount: nil, threadID: "active-thread"
        )
        return ActivitySnapshot(
            waitingTasks: waiting ? [task] : [], runningTasks: waiting ? [] : [task], recentCompletions: [], recentTerminations: []
        )
    }
}