Skip to content

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

13.5 KB
Raw Blame
import AppKit
import Testing

struct TaskGlowTests {
    @Test(arguments: ["#", " ", "\t\n", "中文", "😀", "éß12", "!@#$%^&*()"])
    func nonAlphanumericInputPreservesSelectedColor(_ input: String) {
        let formatter = TaskGlowHexFormatter()
        let original = "123456"
        let selectedRange = NSRange(location: 2, length: 2)
        var proposed = (original as NSString).replacingCharacters(in: selectedRange, with: input) as NSString
        var proposedRange = NSRange(location: 2 + (input as NSString).length, length: 0)
        #expect(!formatter.isPartialStringValid(
            &proposed,
            proposedSelectedRange: &proposedRange,
            originalString: original,
            originalSelectedRange: selectedRange,
            errorDescription: nil
        ))
        #expect(proposed as String == original)
        #expect(proposedRange == selectedRange)
    }

    @Test func pastedColorFiltersNonAlphanumericCharactersBeforeApplyingLengthLimit() {
        let formatter = TaskGlowHexFormatter()
        var proposed: NSString = " #a b-1😀2\t中e_f!78 "
        var proposedRange = NSRange(location: proposed.length, length: 0)
        #expect(!formatter.isPartialStringValid(
            &proposed,
            proposedSelectedRange: &proposedRange,
            originalString: "",
            originalSelectedRange: NSRange(location: 0, length: 0),
            errorDescription: nil
        ))
        #expect(proposed as String == "AB12EF")
        #expect(proposedRange == NSRange(location: 6, length: 0))
    }

    @Test(arguments: [0, 2, 6])
    func overflowPreservesColorAndSelection(_ cursor: Int) {
        let formatter = TaskGlowHexFormatter()
        let original = "123456"
        let originalRange = NSRange(location: cursor, length: 0)
        var proposed = (original as NSString).replacingCharacters(in: originalRange, with: "a") as NSString
        var proposedRange = NSRange(location: cursor + 1, length: 0)
        #expect(!formatter.isPartialStringValid(
            &proposed,
            proposedSelectedRange: &proposedRange,
            originalString: original,
            originalSelectedRange: originalRange,
            errorDescription: nil
        ))
        #expect(proposed as String == original)
        #expect(proposedRange == originalRange)
    }

    @Test func colorFormatterLimitsReplacementWithoutChangingSurroundingText() {
        let formatter = TaskGlowHexFormatter()
        var proposed: NSString = "12abcdef56"
        var proposedRange = NSRange(location: 8, length: 0)
        #expect(!formatter.isPartialStringValid(
            &proposed,
            proposedSelectedRange: &proposedRange,
            originalString: "123456",
            originalSelectedRange: NSRange(location: 2, length: 2),
            errorDescription: nil
        ))
        #expect(proposed as String == "12AB56")
        #expect(proposedRange == NSRange(location: 4, length: 0))
    }

    @Test func colorStoragePreservesDisplayP3Components() throws {
        let color = NSColor(displayP3Red: 128.0 / 255, green: 1, blue: 0, alpha: 1)
        let hex = try #require(TaskGlowAppearance.encodeColor(color))
        #expect(hex == "80FF00")
        let restored = try #require(TaskGlowAppearance.decodeColor(hex))
        #expect(restored.colorSpace == .displayP3)
        #expect(abs(restored.redComponent - color.redComponent) < 0.0001)
        #expect(restored.greenComponent == 1)
        #expect(restored.blueComponent == 0)
    }

    @Test func existingEnabledPreferenceKeepsOriginalAppearance() throws {
        let preferences = try TestPreferences()
        defer { preferences.remove() }
        preferences.defaults.set(true, forKey: "TaskGlow.isEnabled")
        let settings = TaskGlowSettings(defaults: preferences.defaults)
        #expect(settings.isEnabled)
        #expect(settings.appearance == TaskGlowAppearance())
        #expect(settings.appearance.color(for: .running) == .systemCyan)
        #expect(settings.appearance.color(for: .waiting) == .systemOrange)
        #expect(settings.appearance.color(for: .completed) == .systemGreen)
        #expect(settings.appearance.color(for: .terminated) == .systemRed)
    }

    @Test func appearancePersistsAndRefreshesWithoutChangingEnabledPreference() throws {
        let preferences = try TestPreferences()
        defer { preferences.remove() }
        let settings = TaskGlowSettings(defaults: preferences.defaults)
        let observer = TaskGlowSettings(defaults: preferences.defaults)
        for (role, hex) in zip(TaskGlowColorRole.allCases, ["123456", "ABCDEF", "00FF00", "FF0000"]) {
            settings.setColorHex(hex, for: role)
            #expect(settings.appearance.colors[role] == hex)
        }
        settings.setAnimationSpeed(.slow)
        settings.setTerminalDuration(15)
        settings.setBrightness(0.45)
        observer.refresh()
        #expect(observer.appearance == settings.appearance)
        #expect(TaskGlowSettings(defaults: preferences.defaults).appearance == settings.appearance)
        #expect(!observer.isEnabled)
        #expect(preferences.defaults.object(forKey: "TaskGlow.isEnabled") == nil)
    }

    @Test func hexInputNormalizesValidColorsAndPreservesSavedColorWhileEditing() throws {
        let preferences = try TestPreferences()
        defer { preferences.remove() }
        let settings = TaskGlowSettings(defaults: preferences.defaults)
        settings.setColorHex("  #ab12ef\n", for: .running)
        #expect(settings.appearance.colors[.running] == "AB12EF")
        #expect(preferences.defaults.string(forKey: "TaskGlow.color.running") == "AB12EF")
        for invalid in ["#", "#abc", "12345", "1234567", "#12345678", "GGGGGG", "##123456", "12 3456"] {
            settings.setColorHex(invalid, for: .running)
            #expect(settings.appearance.colors[.running] == "AB12EF")
            #expect(preferences.defaults.string(forKey: "TaskGlow.color.running") == "AB12EF")
        }
        settings.setColorHex("12abef", for: .running)
        #expect(TaskGlowSettings(defaults: preferences.defaults).appearance.colors[.running] == "12ABEF")
        settings.setColorHex(" \n", for: .running)
        #expect(settings.appearance.colors[.running] == nil)
        #expect(preferences.defaults.object(forKey: "TaskGlow.color.running") == nil)
        #expect(TaskGlowSettings(defaults: preferences.defaults).appearance.color(for: .running) == .systemCyan)
    }

    @Test func invalidAppearanceValuesFallBackAndInvalidWritesAreIgnored() throws {
        let preferences = try TestPreferences()
        defer { preferences.remove() }
        preferences.defaults.set("invalid", forKey: "TaskGlow.color.running")
        preferences.defaults.set("FFFFFFF", forKey: "TaskGlow.color.waiting")
        preferences.defaults.set("future", forKey: "TaskGlow.animationSpeed")
        preferences.defaults.set(-2, forKey: "TaskGlow.terminalDurationSeconds")
        preferences.defaults.set(4, forKey: "TaskGlow.brightness")
        let settings = TaskGlowSettings(defaults: preferences.defaults)
        #expect(settings.appearance == TaskGlowAppearance())
        settings.setTerminalDuration(.infinity)
        settings.setTerminalDuration(0)
        settings.setBrightness(.nan)
        #expect(settings.appearance == TaskGlowAppearance())
        settings.setBrightness(-1)
        #expect(settings.appearance.brightness == 0.2)
        settings.setBrightness(2)
        #expect(settings.appearance.brightness == 1)
        #expect(TaskGlowAppearance.decodeColor("-12345") == nil)
        #expect(TaskGlowAppearance.decodeColor("GGGGGG") == nil)
    }

    @Test(arguments: TaskGlowSettings.terminalDurationOptions)
    func terminalDurationControlsGlowExpiration(_ duration: TimeInterval) {
        let snapshot = completedSnapshot()
        var presentation = TaskGlowPresentationState()
        presentation.update(snapshot: snapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now)
        presentation.refresh(now: TestFixtures.now, terminalDuration: duration)
        #expect(presentation.state == .completed)
        #expect(presentation.terminal?.expiresAt == TestFixtures.now.addingTimeInterval(duration))
        presentation.refresh(now: TestFixtures.now.addingTimeInterval(duration), terminalDuration: duration)
        #expect(presentation.state == .hidden)
        #expect(presentation.terminal == nil)
    }

    @Test func changingDurationPreservesEntranceAndWakeDoesNotReplayExpiredGlow() {
        var presentation = TaskGlowPresentationState()
        presentation.update(snapshot: completedSnapshot(), terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now)
        presentation.refresh(now: TestFixtures.now, terminalDuration: 10)
        presentation.refresh(now: TestFixtures.now.addingTimeInterval(2), terminalDuration: 15)
        #expect(presentation.terminal?.startedAt == TestFixtures.now)
        #expect(presentation.terminal?.expiresAt == TestFixtures.now.addingTimeInterval(15))
        presentation.refresh(now: TestFixtures.now.addingTimeInterval(16), terminalDuration: 15)
        #expect(presentation.state == .hidden)
    }

    @Test func repeatedTerminalRefreshPreservesPresentationAndNewEventRestartsEntrance() throws {
        let snapshot = completedSnapshot()
        var presentation = TaskGlowPresentationState()
        presentation.update(snapshot: snapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now)
        presentation.refresh(now: TestFixtures.now, terminalDuration: 10)
        let original = try #require(presentation.terminal)
        presentation.refresh(now: TestFixtures.now.addingTimeInterval(2), terminalDuration: 10)
        #expect(presentation.terminal == original)

        let nextSnapshot = completedSnapshot()
        let nextPresentationTime = TestFixtures.now.addingTimeInterval(3)
        presentation.update(snapshot: nextSnapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: nextPresentationTime)
        presentation.refresh(now: nextPresentationTime, terminalDuration: 10)
        #expect(presentation.terminal?.eventID == nextSnapshot.latestTerminalEvent?.id)
        #expect(presentation.terminal?.eventID != original.eventID)
        #expect(presentation.terminal?.startedAt == nextPresentationTime)
    }

    @Test func liveInputWaitMatchesPanelAndReturnsToRunningAfterResponse() {
        var task = ActivityTaskSnapshot(
            id: UUID(), projectName: nil, modelName: nil, effort: nil, startedAt: TestFixtures.now,
            stateChangedAt: TestFixtures.now, activeSubagentCount: nil, threadID: "input-thread"
        )
        var presentation = TaskGlowPresentationState()
        for waiting in [false, true, false] {
            task.presentation = ActivityLiveSummary(
                current: ActivityLiveLabel(waiting ? "waiting-input" : "replying"),
                waiting: waiting ? ActivityLiveWait(label: ActivityLiveLabel("waiting-input"), since: TestFixtures.now) : nil
            )
            let snapshot = ActivitySnapshot(waitingTasks: [], runningTasks: [task], recentCompletions: [], recentTerminations: [])
            presentation.update(snapshot: snapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now)
            presentation.refresh(now: TestFixtures.now, terminalDuration: 10)
            #expect(snapshot.waitingCount == 0)
            #expect(snapshot.runningCount == 1)
            #expect(snapshot.panelWaitingTasks.isEmpty == !waiting)
            #expect(presentation.state == (waiting ? .waiting : .running))
        }
    }

    @Test(arguments: [false, true])
    func concurrentTaskCompletionStillShowsBrieflyThenRestoresActiveState(waiting: Bool) throws {
        var presentation = TaskGlowPresentationState()
        var running = ActivityTaskSnapshot(
            id: UUID(), projectName: nil,
            modelName: nil, effort: nil, startedAt: TestFixtures.now,
            stateChangedAt: TestFixtures.now, activeSubagentCount: nil, threadID: "running-thread"
        )
        if waiting {
            running.presentation = ActivityLiveSummary(
                current: ActivityLiveLabel("waiting-input"),
                waiting: ActivityLiveWait(label: ActivityLiveLabel("waiting-input"), since: TestFixtures.now)
            )
        }
        let snapshot = ActivitySnapshot(
            waitingTasks: [], runningTasks: [running],
            recentCompletions: completedSnapshot().recentCompletions, recentTerminations: []
        )
        presentation.update(snapshot: snapshot, terminalEvents: [], isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now)
        try presentation.update(
            snapshot: snapshot, terminalEvents: [#require(snapshot.latestTerminalEvent)],
            isEnabled: true, acceptsBriefEvents: true, now: TestFixtures.now
        )
        presentation.refresh(now: TestFixtures.now, terminalDuration: 15)
        #expect(presentation.state == .completed)
        #expect(presentation.terminal?.expiresAt == TestFixtures.now.addingTimeInterval(3))
        presentation.refresh(now: TestFixtures.now.addingTimeInterval(3), terminalDuration: 15)
        #expect(presentation.state == (waiting ? .waiting : .running))
    }

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