wehub-resource-sync
893 lines
36 KiB
Swift
893 lines
36 KiB
Swift
import AppKit
|
||
import CodexBarCore
|
||
import Foundation
|
||
import Testing
|
||
@testable import CodexBar
|
||
|
||
struct CodexBarTests {
|
||
@Test
|
||
func `icon renderer produces template image`() {
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: 50,
|
||
weeklyRemaining: 75,
|
||
creditsRemaining: 500,
|
||
stale: false,
|
||
style: .codex)
|
||
#expect(image.isTemplate)
|
||
#expect(image.size.width > 0)
|
||
}
|
||
|
||
@Test
|
||
func `icon renderer renders at pixel aligned size`() {
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: 50,
|
||
weeklyRemaining: 75,
|
||
creditsRemaining: 500,
|
||
stale: false,
|
||
style: .claude)
|
||
let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
|
||
#expect(bitmapReps.contains { rep in
|
||
rep.pixelsWide == 36 && rep.pixelsHigh == 36
|
||
})
|
||
}
|
||
|
||
@Test
|
||
func `icon renderer caches static icons`() {
|
||
let first = IconRenderer.makeIcon(
|
||
primaryRemaining: 42,
|
||
weeklyRemaining: 17,
|
||
creditsRemaining: 250,
|
||
stale: false,
|
||
style: .codex)
|
||
let second = IconRenderer.makeIcon(
|
||
primaryRemaining: 42,
|
||
weeklyRemaining: 17,
|
||
creditsRemaining: 250,
|
||
stale: false,
|
||
style: .codex)
|
||
#expect(first === second)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity icon ignores legacy model quota lanes`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 60, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
tertiary: RateWindow(usedPercent: 80, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-compact-fallback-model",
|
||
title: "New Model",
|
||
window: RateWindow(
|
||
usedPercent: 64,
|
||
windowMinutes: nil,
|
||
resetsAt: nil,
|
||
resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(remaining.primary == nil)
|
||
#expect(remaining.secondary == nil)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon shows session on top and weekly on bottom`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 84, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-weekly",
|
||
title: "Gemini Weekly",
|
||
window: RateWindow(usedPercent: 84, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(usedPercent: 97, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Claude + GPT Weekly",
|
||
window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-5h",
|
||
title: "Claude + GPT Session",
|
||
window: RateWindow(usedPercent: 98, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary?.windowMinutes == 300)
|
||
#expect(windows.primary?.remainingPercent == 2)
|
||
#expect(windows.secondary?.windowMinutes == 10080)
|
||
#expect(windows.secondary?.remainingPercent == 1)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity renderer draws primary above secondary`() throws {
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: 100,
|
||
weeklyRemaining: 10,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .antigravity)
|
||
let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
|
||
let matchingRep = bitmapReps.first { rep in
|
||
rep.pixelsWide == 36 && rep.pixelsHigh == 36
|
||
}
|
||
let rep = try #require(matchingRep)
|
||
|
||
func averageAlpha(xRange: ClosedRange<Int>, yRange: ClosedRange<Int>) -> CGFloat {
|
||
var total: CGFloat = 0
|
||
var count: CGFloat = 0
|
||
for y in yRange {
|
||
for x in xRange {
|
||
total += (rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
|
||
count += 1
|
||
}
|
||
}
|
||
return total / count
|
||
}
|
||
|
||
let visualTopRightAlpha = averageAlpha(xRange: 24...30, yRange: 7...10)
|
||
let visualBottomRightAlpha = averageAlpha(xRange: 24...30, yRange: 22...28)
|
||
|
||
#expect(visualTopRightAlpha > visualBottomRightAlpha + 0.2)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon uses most constrained quota summary lanes`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-weekly",
|
||
title: "Renamed Weekly",
|
||
window: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-5h",
|
||
title: "Renamed Session",
|
||
window: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Gemini Weekly",
|
||
window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(usedPercent: 98, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary?.remainingPercent == 2)
|
||
#expect(windows.secondary?.remainingPercent == 1)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon can pair gemini session with claude gpt weekly`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Claude + GPT Weekly",
|
||
window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary?.remainingPercent == 60)
|
||
#expect(windows.secondary?.remainingPercent == 1)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon ignores unknown rows while ranking known lanes`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-weekly",
|
||
title: "Gemini Weekly",
|
||
window: RateWindow(usedPercent: 100, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
|
||
usageKnown: false),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Claude + GPT Weekly",
|
||
window: RateWindow(usedPercent: 99, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary == nil)
|
||
#expect(windows.secondary?.remainingPercent == 1)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity used icon percent matches constrained claude gpt lane`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(usedPercent: 20, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-weekly",
|
||
title: "Gemini Weekly",
|
||
window: RateWindow(usedPercent: 30, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-5h",
|
||
title: "Claude + GPT Session",
|
||
window: RateWindow(usedPercent: 95, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Claude + GPT Weekly",
|
||
window: RateWindow(usedPercent: 40, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let percents = IconRemainingResolver.resolvedPercents(
|
||
snapshot: snapshot,
|
||
style: .antigravity,
|
||
showUsed: true)
|
||
|
||
#expect(percents.primary == 95)
|
||
#expect(percents.secondary == 40)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon falls back when gemini rows are absent`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-5h",
|
||
title: "Claude + GPT Session",
|
||
window: RateWindow(usedPercent: 75, windowMinutes: 300, resetsAt: nil, resetDescription: nil)),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-3p-weekly",
|
||
title: "Claude + GPT Weekly",
|
||
window: RateWindow(usedPercent: 88, windowMinutes: 10080, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary?.remainingPercent == 25)
|
||
#expect(windows.secondary?.remainingPercent == 12)
|
||
}
|
||
|
||
@Test
|
||
func `antigravity quota summary icon tie break is stable`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: nil,
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-z-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(
|
||
usedPercent: 50,
|
||
windowMinutes: 300,
|
||
resetsAt: nil,
|
||
resetDescription: "second-by-id")),
|
||
NamedRateWindow(
|
||
id: "antigravity-quota-summary-gemini-a-5h",
|
||
title: "Gemini Session",
|
||
window: RateWindow(
|
||
usedPercent: 50,
|
||
windowMinutes: 300,
|
||
resetsAt: nil,
|
||
resetDescription: "first-by-id")),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let windows = IconRemainingResolver.resolvedWindows(snapshot: snapshot, style: .antigravity)
|
||
|
||
#expect(windows.primary?.resetDescription == "first-by-id")
|
||
#expect(windows.secondary == nil)
|
||
}
|
||
|
||
@Test
|
||
func `perplexity icon falls back to purchased lane when bonus is exhausted`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
tertiary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
|
||
#expect(remaining.primary == 80)
|
||
#expect(remaining.secondary == 0)
|
||
}
|
||
|
||
@Test
|
||
func `perplexity icon skips exhausted recurring lane when purchased credits remain`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
tertiary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
|
||
#expect(remaining.primary == 80)
|
||
#expect(remaining.secondary == 0)
|
||
}
|
||
|
||
@Test
|
||
func `perplexity icon prefers purchased lane before bonus`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
tertiary: RateWindow(usedPercent: 45, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .perplexity)
|
||
#expect(remaining.primary == 55)
|
||
#expect(remaining.secondary == 80)
|
||
}
|
||
|
||
@Test
|
||
func `kimi icon renders primary bar when secondary is nil`() throws {
|
||
// Regression: Kimi account connected with usage, but no progress bar shown (issue #1043).
|
||
// When secondary (rate limit) is absent, the icon renderer must still show
|
||
// the primary (weekly quota) bar.
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 18.3, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: nil,
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .kimi)
|
||
|
||
guard let primaryRemaining = remaining.primary else {
|
||
Issue.record("remaining.primary was nil after IconRemainingResolver check")
|
||
return
|
||
}
|
||
#expect(primaryRemaining > 0) // 81.7% remaining
|
||
#expect(remaining.secondary == nil)
|
||
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: remaining.primary,
|
||
weeklyRemaining: remaining.secondary,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .kimi)
|
||
#expect(image.size.width > 0)
|
||
#expect(image.isTemplate)
|
||
|
||
// Prove the primary bar is actually rendered using pixel inspection.
|
||
// Top bar rect: x ∈ [3, 33], y ∈ [19, 31] in the 36×36 canvas (barXPx=3, barWidthPx=30, y=19, h=12).
|
||
let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
|
||
let rep = try #require(bitmapReps.first { $0.pixelsWide == 36 && $0.pixelsHigh == 36 })
|
||
|
||
func alphaAt(px x: Int, _ y: Int) -> CGFloat {
|
||
(rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
|
||
}
|
||
|
||
func regionHasFill(xRange: ClosedRange<Int>, yRange: ClosedRange<Int>) -> Bool {
|
||
for y in yRange {
|
||
for x in xRange where alphaAt(px: x, y) > 0.05 {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// Primary bar (top track) must have fill to prove the progress bar rendered.
|
||
#expect(regionHasFill(xRange: 3...33, yRange: 19...31))
|
||
}
|
||
|
||
@Test
|
||
func `copilot icon can use selected budget as secondary lane`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "copilot-budget-agent",
|
||
title: "Budget - Copilot Agent Premium Requests",
|
||
window: RateWindow(usedPercent: 65, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(
|
||
snapshot: snapshot,
|
||
style: .copilot,
|
||
secondaryOverrideWindowID: "copilot-budget-agent")
|
||
|
||
#expect(remaining.primary == 80)
|
||
#expect(remaining.secondary == 35)
|
||
}
|
||
|
||
@Test
|
||
func `copying extra rate windows preserves subscription dates`() {
|
||
let expiresAt = Date(timeIntervalSince1970: 1_810_656_000)
|
||
let renewsAt = Date(timeIntervalSince1970: 1_810_569_600)
|
||
let ampUsage = AmpUsageDetails(
|
||
individualCredits: 12.5,
|
||
workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 7.25)])
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
ampUsage: ampUsage,
|
||
subscriptionExpiresAt: expiresAt,
|
||
subscriptionRenewsAt: renewsAt,
|
||
updatedAt: Date(timeIntervalSince1970: 1_800_000_000))
|
||
|
||
let copied = snapshot.with(extraRateWindows: [])
|
||
|
||
#expect(copied.subscriptionExpiresAt == expiresAt)
|
||
#expect(copied.subscriptionRenewsAt == renewsAt)
|
||
#expect(copied.ampUsage == ampUsage)
|
||
}
|
||
|
||
@Test
|
||
func `copying rate windows preserves provider payloads`() {
|
||
let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
|
||
let mimoUsage = MiMoUsageSnapshot(
|
||
balance: 12.5,
|
||
currency: "USD",
|
||
tokenUsed: 25,
|
||
tokenLimit: 100,
|
||
tokenPercent: 0.25,
|
||
updatedAt: updatedAt)
|
||
let identity = ProviderIdentitySnapshot(
|
||
providerID: .codex,
|
||
accountEmail: "test@example.com",
|
||
accountOrganization: "Example",
|
||
loginMethod: "OAuth")
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
tertiary: RateWindow(usedPercent: 30, windowMinutes: 60, resetsAt: nil, resetDescription: nil),
|
||
mimoUsage: mimoUsage,
|
||
cursorRequests: CursorRequestUsage(used: 10, limit: 50),
|
||
subscriptionExpiresAt: updatedAt.addingTimeInterval(100),
|
||
subscriptionRenewsAt: updatedAt.addingTimeInterval(200),
|
||
updatedAt: updatedAt,
|
||
identity: identity)
|
||
|
||
let copied = snapshot.with(
|
||
primary: RateWindow(usedPercent: 40, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 50, windowMinutes: 10080, resetsAt: nil, resetDescription: nil))
|
||
|
||
#expect(copied.primary?.usedPercent == 40)
|
||
#expect(copied.secondary?.usedPercent == 50)
|
||
#expect(copied.tertiary?.usedPercent == 30)
|
||
#expect(copied.mimoUsage?.balance == 12.5)
|
||
#expect(copied.cursorRequests?.used == 10)
|
||
#expect(copied.subscriptionExpiresAt == updatedAt.addingTimeInterval(100))
|
||
#expect(copied.subscriptionRenewsAt == updatedAt.addingTimeInterval(200))
|
||
#expect(copied.identity?.accountOrganization == "Example")
|
||
}
|
||
|
||
@Test
|
||
func `copying identity preserves provider payloads`() {
|
||
let updatedAt = Date(timeIntervalSince1970: 1_800_000_000)
|
||
let ampUsage = AmpUsageDetails(
|
||
individualCredits: 12.5,
|
||
workspaceBalances: [AmpWorkspaceBalance(name: "Team", remaining: 7.25)])
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: nil,
|
||
ampUsage: ampUsage,
|
||
cursorRequests: CursorRequestUsage(used: 10, limit: 50),
|
||
subscriptionExpiresAt: updatedAt.addingTimeInterval(100),
|
||
subscriptionRenewsAt: updatedAt.addingTimeInterval(200),
|
||
updatedAt: updatedAt)
|
||
let identity = ProviderIdentitySnapshot(
|
||
providerID: .kilo,
|
||
accountEmail: "test@example.com",
|
||
accountOrganization: "Example",
|
||
loginMethod: "API")
|
||
|
||
let copied = snapshot.withIdentity(identity)
|
||
|
||
#expect(copied.ampUsage == ampUsage)
|
||
#expect(copied.cursorRequests?.used == 10)
|
||
#expect(copied.subscriptionExpiresAt == updatedAt.addingTimeInterval(100))
|
||
#expect(copied.subscriptionRenewsAt == updatedAt.addingTimeInterval(200))
|
||
#expect(copied.identity?.accountOrganization == "Example")
|
||
}
|
||
|
||
@Test
|
||
func `copilot icon falls back to chat lane when selected budget is unavailable`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
extraRateWindows: nil,
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(
|
||
snapshot: snapshot,
|
||
style: .copilot,
|
||
secondaryOverrideWindowID: "copilot-budget-agent")
|
||
|
||
#expect(remaining.primary == 80)
|
||
#expect(remaining.secondary == 70)
|
||
}
|
||
|
||
@Test
|
||
func `copilot icon uses selected budget in show used mode`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 20, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 30, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
extraRateWindows: [
|
||
NamedRateWindow(
|
||
id: "copilot-budget-agent",
|
||
title: "Budget - Copilot Agent Premium Requests",
|
||
window: RateWindow(usedPercent: 65, windowMinutes: nil, resetsAt: nil, resetDescription: nil)),
|
||
],
|
||
updatedAt: Date())
|
||
|
||
let percents = IconRemainingResolver.resolvedPercents(
|
||
snapshot: snapshot,
|
||
style: .copilot,
|
||
showUsed: true,
|
||
secondaryOverrideWindowID: "copilot-budget-agent")
|
||
|
||
#expect(percents.primary == 20)
|
||
#expect(percents.secondary == 65)
|
||
}
|
||
|
||
@Test
|
||
func `warp icon preserves exhausted bonus layout in show used mode`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let percents = IconRemainingResolver.resolvedPercents(
|
||
snapshot: snapshot,
|
||
style: .warp,
|
||
showUsed: true)
|
||
|
||
#expect(percents.primary == 10)
|
||
#expect(percents.secondary == 0)
|
||
}
|
||
|
||
@Test
|
||
func `warp icon keeps unused bonus lane visible in show used mode`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 0, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let percents = IconRemainingResolver.resolvedPercents(
|
||
snapshot: snapshot,
|
||
style: .warp,
|
||
showUsed: true)
|
||
|
||
#expect(percents.primary == 10)
|
||
#expect(percents.secondary != nil)
|
||
#expect(percents.secondary ?? 1 < 0.01)
|
||
}
|
||
|
||
@Test
|
||
func `merged icon keeps exhausted warp bonus fully used`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(usedPercent: 10, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
secondary: RateWindow(usedPercent: 100, windowMinutes: nil, resetsAt: nil, resetDescription: nil),
|
||
updatedAt: Date())
|
||
|
||
let percents = IconRemainingResolver.resolvedPercents(
|
||
snapshot: snapshot,
|
||
style: .warp,
|
||
showUsed: true,
|
||
renderingStyle: .combined)
|
||
|
||
#expect(percents.primary == 10)
|
||
#expect(percents.secondary == 100)
|
||
}
|
||
|
||
@Test
|
||
@MainActor
|
||
func `status icon accessibility uses percentage scale`() {
|
||
#expect(
|
||
StatusIconView.accessibilityPercentRemaining(50) ==
|
||
String(format: L("%d percent remaining"), 50))
|
||
}
|
||
|
||
@Test
|
||
func `codex icon promotes weekly only window into primary display lane`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: RateWindow(usedPercent: 25, windowMinutes: 10080, resetsAt: nil, resetDescription: nil),
|
||
tertiary: nil,
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .codex)
|
||
#expect(remaining.primary == 75)
|
||
#expect(remaining.secondary == nil)
|
||
}
|
||
|
||
@Test
|
||
func `codex icon uses semantic projection lanes when durations drift`() {
|
||
let snapshot = UsageSnapshot(
|
||
primary: nil,
|
||
secondary: RateWindow(usedPercent: 25, windowMinutes: 11040, resetsAt: nil, resetDescription: nil),
|
||
tertiary: nil,
|
||
updatedAt: Date())
|
||
|
||
let remaining = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .codex)
|
||
#expect(remaining.primary == 75)
|
||
#expect(remaining.secondary == nil)
|
||
}
|
||
|
||
@Test
|
||
func `codex icon caps session only until exhausted weekly lane resets`() {
|
||
let now = Date(timeIntervalSince1970: 1_800_000_000)
|
||
let weeklyReset = now.addingTimeInterval(3600)
|
||
let snapshot = UsageSnapshot(
|
||
primary: RateWindow(
|
||
usedPercent: 1,
|
||
windowMinutes: 300,
|
||
resetsAt: now.addingTimeInterval(1800),
|
||
resetDescription: nil),
|
||
secondary: RateWindow(
|
||
usedPercent: 100,
|
||
windowMinutes: 10080,
|
||
resetsAt: weeklyReset,
|
||
resetDescription: nil),
|
||
updatedAt: now.addingTimeInterval(-7200))
|
||
|
||
let capped = IconRemainingResolver.resolvedRemaining(snapshot: snapshot, style: .codex, now: now)
|
||
let reset = IconRemainingResolver.resolvedRemaining(
|
||
snapshot: snapshot,
|
||
style: .codex,
|
||
now: weeklyReset)
|
||
|
||
#expect(capped.primary == 0)
|
||
#expect(capped.secondary == 0)
|
||
#expect(reset.primary == 99)
|
||
#expect(reset.secondary == nil)
|
||
}
|
||
|
||
@Test
|
||
func `status overlays cut halos through the quota bar and keep glyphs visible`() throws {
|
||
let plain = IconRenderer.makeIcon(
|
||
primaryRemaining: 100,
|
||
weeklyRemaining: 100,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .combined,
|
||
statusIndicator: .none)
|
||
let plainRep = try #require(plain.representations.compactMap { $0 as? NSBitmapImageRep }.first {
|
||
$0.pixelsWide == 36 && $0.pixelsHigh == 36
|
||
})
|
||
|
||
func alpha(_ rep: NSBitmapImageRep, x: Int, y: Int) -> CGFloat {
|
||
(rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
|
||
}
|
||
|
||
for indicator in [ProviderStatusIndicator.minor, .major] {
|
||
let marked = IconRenderer.makeIcon(
|
||
primaryRemaining: 100,
|
||
weeklyRemaining: 100,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .combined,
|
||
statusIndicator: indicator)
|
||
let markedRep = try #require(marked.representations.compactMap { $0 as? NSBitmapImageRep }.first {
|
||
$0.pixelsWide == 36 && $0.pixelsHigh == 36
|
||
})
|
||
|
||
var cutoutPixels = 0
|
||
var glyphPixels = 0
|
||
for y in 0..<markedRep.pixelsHigh {
|
||
for x in 0..<markedRep.pixelsWide {
|
||
let plainAlpha = alpha(plainRep, x: x, y: y)
|
||
let markedAlpha = alpha(markedRep, x: x, y: y)
|
||
if plainAlpha > 0.5, markedAlpha < 0.05 {
|
||
cutoutPixels += 1
|
||
}
|
||
if plainAlpha < 0.05, markedAlpha > 0.5 {
|
||
glyphPixels += 1
|
||
}
|
||
}
|
||
}
|
||
|
||
#expect(cutoutPixels >= 8, "Expected halo cutout pixels for \(indicator)")
|
||
#expect(glyphPixels >= 4, "Expected visible glyph pixels for \(indicator)")
|
||
}
|
||
}
|
||
|
||
@Test
|
||
func `icon renderer codex eyes punch through when unknown`() {
|
||
// Regression: when remaining is nil, CoreGraphics inherits the previous fill alpha which caused
|
||
// destinationOut “eyes” to become semi-transparent instead of fully punched through.
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: nil,
|
||
weeklyRemaining: 1,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .codex)
|
||
|
||
let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
|
||
let rep = bitmapReps.first(where: { $0.pixelsWide == 36 && $0.pixelsHigh == 36 })
|
||
#expect(rep != nil)
|
||
guard let rep else { return }
|
||
|
||
func alphaAt(px x: Int, _ y: Int) -> CGFloat {
|
||
(rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
|
||
}
|
||
|
||
let w = rep.pixelsWide
|
||
let h = rep.pixelsHigh
|
||
let isTransparent: (Int, Int) -> Bool = { x, y in
|
||
alphaAt(px: x, y) < 0.05
|
||
}
|
||
|
||
// Flood-fill from the border through transparent pixels to label the "outside".
|
||
var visited = Array(repeating: Array(repeating: false, count: w), count: h)
|
||
var queue: [(Int, Int)] = []
|
||
queue.reserveCapacity(w * 2 + h * 2)
|
||
|
||
func enqueueIfOutside(_ x: Int, _ y: Int) {
|
||
guard x >= 0, x < w, y >= 0, y < h else { return }
|
||
guard !visited[y][x], isTransparent(x, y) else { return }
|
||
visited[y][x] = true
|
||
queue.append((x, y))
|
||
}
|
||
|
||
for x in 0..<w {
|
||
enqueueIfOutside(x, 0)
|
||
enqueueIfOutside(x, h - 1)
|
||
}
|
||
for y in 0..<h {
|
||
enqueueIfOutside(0, y)
|
||
enqueueIfOutside(w - 1, y)
|
||
}
|
||
|
||
while let (x, y) = queue.first {
|
||
queue.removeFirst()
|
||
enqueueIfOutside(x + 1, y)
|
||
enqueueIfOutside(x - 1, y)
|
||
enqueueIfOutside(x, y + 1)
|
||
enqueueIfOutside(x, y - 1)
|
||
}
|
||
|
||
// Any remaining transparent pixels not reachable from the border are internal holes (i.e. the eyes).
|
||
var internalHoles = 0
|
||
for y in 0..<h {
|
||
for x in 0..<w where isTransparent(x, y) && !visited[y][x] {
|
||
internalHoles += 1
|
||
}
|
||
}
|
||
|
||
#expect(internalHoles >= 16) // at least one 4×4 eye block, but typically two eyes => 32
|
||
}
|
||
|
||
@Test
|
||
func `icon renderer warp eyes cut out at expected centers`() {
|
||
// Regression: Warp eyes should be tilted in-place and remain centered on the face.
|
||
let image = IconRenderer.makeIcon(
|
||
primaryRemaining: 50,
|
||
weeklyRemaining: 50,
|
||
creditsRemaining: nil,
|
||
stale: false,
|
||
style: .warp)
|
||
|
||
let bitmapReps = image.representations.compactMap { $0 as? NSBitmapImageRep }
|
||
let rep = bitmapReps.first(where: { $0.pixelsWide == 36 && $0.pixelsHigh == 36 })
|
||
#expect(rep != nil)
|
||
guard let rep else { return }
|
||
|
||
func alphaAt(px x: Int, _ y: Int) -> CGFloat {
|
||
(rep.colorAt(x: x, y: y) ?? .clear).alphaComponent
|
||
}
|
||
|
||
func minAlphaNear(px cx: Int, _ cy: Int, radius: Int) -> CGFloat {
|
||
var minAlpha: CGFloat = 1.0
|
||
let x0 = max(0, cx - radius)
|
||
let x1 = min(rep.pixelsWide - 1, cx + radius)
|
||
let y0 = max(0, cy - radius)
|
||
let y1 = min(rep.pixelsHigh - 1, cy + radius)
|
||
for y in y0...y1 {
|
||
for x in x0...x1 {
|
||
minAlpha = min(minAlpha, alphaAt(px: x, y))
|
||
}
|
||
}
|
||
return minAlpha
|
||
}
|
||
|
||
func minAlphaNearEitherOrigin(px cx: Int, _ cy: Int, radius: Int) -> CGFloat {
|
||
let flippedY = (rep.pixelsHigh - 1) - cy
|
||
return min(minAlphaNear(px: cx, cy, radius: radius), minAlphaNear(px: cx, flippedY, radius: radius))
|
||
}
|
||
|
||
// These are the center pixels for the two Warp eye cutouts in the top bar (36×36 canvas).
|
||
// If the eyes are rotated around the wrong origin, these points will not be fully punched out.
|
||
let leftEyeCenter = (x: 11, y: 25)
|
||
let rightEyeCenter = (x: 25, y: 25)
|
||
|
||
// The eye ellipse height is even (8 px), so the exact center can land between pixel rows.
|
||
// Assert via a small neighborhood search rather than a single pixel.
|
||
#expect(minAlphaNearEitherOrigin(px: leftEyeCenter.x, leftEyeCenter.y, radius: 2) < 0.05)
|
||
#expect(minAlphaNearEitherOrigin(px: rightEyeCenter.x, rightEyeCenter.y, radius: 2) < 0.05)
|
||
|
||
// Sanity: nearby top bar track area should remain visible (not everything is transparent).
|
||
let midAlpha = max(alphaAt(px: 18, 25), alphaAt(px: 18, (rep.pixelsHigh - 1) - 25))
|
||
#expect(midAlpha > 0.05)
|
||
}
|
||
|
||
@Test
|
||
func `account info parses snake case auth token`() throws {
|
||
let tmp = try FileManager.default.url(
|
||
for: .itemReplacementDirectory,
|
||
in: .userDomainMask,
|
||
appropriateFor: URL(fileURLWithPath: NSTemporaryDirectory()),
|
||
create: true)
|
||
defer { try? FileManager.default.removeItem(at: tmp) }
|
||
|
||
let token = Self.fakeJWT(email: "user@example.com", plan: "pro")
|
||
let auth = ["tokens": ["id_token": token, "access_token": "access", "refresh_token": "refresh"]]
|
||
let data = try JSONSerialization.data(withJSONObject: auth)
|
||
let authURL = tmp.appendingPathComponent("auth.json")
|
||
try data.write(to: authURL)
|
||
|
||
let fetcher = UsageFetcher(environment: ["CODEX_HOME": tmp.path])
|
||
let account = fetcher.loadAccountInfo()
|
||
#expect(account.email == "user@example.com")
|
||
#expect(account.plan == "pro")
|
||
}
|
||
|
||
@Test
|
||
func `account info parses legacy camel case auth token`() throws {
|
||
let tmp = try FileManager.default.url(
|
||
for: .itemReplacementDirectory,
|
||
in: .userDomainMask,
|
||
appropriateFor: URL(fileURLWithPath: NSTemporaryDirectory()),
|
||
create: true)
|
||
defer { try? FileManager.default.removeItem(at: tmp) }
|
||
|
||
let token = Self.fakeJWT(email: "user@example.com", plan: "pro")
|
||
let auth = ["tokens": ["idToken": token, "accessToken": "access", "refreshToken": "refresh"]]
|
||
let data = try JSONSerialization.data(withJSONObject: auth)
|
||
let authURL = tmp.appendingPathComponent("auth.json")
|
||
try data.write(to: authURL)
|
||
|
||
let fetcher = UsageFetcher(environment: ["CODEX_HOME": tmp.path])
|
||
let account = fetcher.loadAccountInfo()
|
||
#expect(account.email == "user@example.com")
|
||
#expect(account.plan == "pro")
|
||
}
|
||
|
||
private static func fakeJWT(email: String, plan: String) -> String {
|
||
let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data()
|
||
let payload = (try? JSONSerialization.data(withJSONObject: [
|
||
"email": email,
|
||
"chatgpt_plan_type": plan,
|
||
])) ?? Data()
|
||
func b64(_ data: Data) -> String {
|
||
data.base64EncodedString()
|
||
.replacingOccurrences(of: "=", with: "")
|
||
.replacingOccurrences(of: "+", with: "-")
|
||
.replacingOccurrences(of: "/", with: "_")
|
||
}
|
||
return "\(b64(header)).\(b64(payload))."
|
||
}
|
||
}
|