wehub-resource-sync
701 lines
29 KiB
Swift
701 lines
29 KiB
Swift
import AppKit
|
|
import CodexBarCore
|
|
import Testing
|
|
@testable import CodexBar
|
|
|
|
@MainActor
|
|
@Suite(.serialized)
|
|
struct StatusMenuHostedSubmenuRefreshTests {
|
|
@Test
|
|
func `claude swap completion changes open menu readiness`() {
|
|
let settings = Self.makeSettings()
|
|
settings.setProviderEnabled(
|
|
provider: .claude,
|
|
metadata: ProviderDescriptorRegistry.descriptor(for: .claude).metadata,
|
|
enabled: true)
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let before = controller.menuAdjunctReadinessSignature()
|
|
store.claudeSwapRevision &+= 1
|
|
|
|
#expect(controller.menuAdjunctReadinessSignature() != before)
|
|
}
|
|
|
|
@Test
|
|
func `status components change open menu readiness`() {
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = true
|
|
settings.setProviderEnabled(
|
|
provider: .claude,
|
|
metadata: ProviderDescriptorRegistry.descriptor(for: .claude).metadata,
|
|
enabled: true)
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let before = controller.menuAdjunctReadinessSignature()
|
|
store.statusComponents[.claude] = [
|
|
ProviderStatusComponent(
|
|
id: "api",
|
|
name: "API",
|
|
indicator: .none,
|
|
status: "operational"),
|
|
]
|
|
|
|
#expect(controller.menuAdjunctReadinessSignature() != before)
|
|
}
|
|
|
|
@Test
|
|
func `project source changes open menu readiness`() {
|
|
let settings = Self.makeSettings()
|
|
settings.costUsageEnabled = true
|
|
Self.enableOnly(settings, provider: .codex)
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(projectSourcePath: "/tmp/main"), provider: .codex)
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let before = controller.menuAdjunctReadinessSignature()
|
|
store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(projectSourcePath: "/tmp/worktree"), provider: .codex)
|
|
|
|
#expect(controller.menuAdjunctReadinessSignature() != before)
|
|
}
|
|
|
|
@Test
|
|
func `status submenu link stays scoped to its provider`() throws {
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = true
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let submenu = NSMenu()
|
|
#expect(controller.appendStatusComponentsItem(
|
|
to: submenu,
|
|
provider: .claude,
|
|
width: StatusItemController.menuCardBaseWidth))
|
|
#expect(controller.hydrateHostedSubviewMenuIfNeeded(submenu))
|
|
|
|
let link = try #require(submenu.items.last)
|
|
#expect(link.action == #selector(StatusItemController.openStatusPageFromMenuItem(_:)))
|
|
#expect(link.identifier?.rawValue == UsageProvider.claude.rawValue)
|
|
#expect(link.target === controller)
|
|
}
|
|
|
|
@Test
|
|
func `storage native row preserves its plain menu title`() throws {
|
|
let settings = Self.makeSettings()
|
|
settings.providerStorageFootprintsEnabled = true
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
Self.seedStorageFootprint(in: store)
|
|
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let menu = NSMenu()
|
|
#expect(controller.addStorageMenuCardSection(
|
|
to: menu,
|
|
provider: .claude,
|
|
width: StatusItemController.menuCardBaseWidth))
|
|
let item = try #require(menu.items.first)
|
|
#expect(item.title.hasPrefix(L("Storage")))
|
|
#expect(item.title == item.attributedTitle?.string)
|
|
#expect(item.view == nil)
|
|
#expect(item.isEnabled)
|
|
#expect(item.submenu != nil)
|
|
}
|
|
|
|
@Test
|
|
func `open parent menu defers data rebuild until parent tracking ends`() async throws {
|
|
let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
|
|
StatusItemController.menuCardRenderingEnabled = true
|
|
defer {
|
|
StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
|
|
}
|
|
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = false
|
|
settings.refreshFrequency = .manual
|
|
settings.mergeIcons = true
|
|
settings.selectedMenuProvider = .claude
|
|
settings.costUsageEnabled = true
|
|
settings.costSummaryDisplayStyle = .both
|
|
Self.enableOnlyClaude(settings)
|
|
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
Self.seedClaudeSnapshots(in: store)
|
|
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
controller.menuRefreshEnabledOverrideForTesting = false
|
|
|
|
let menu = controller.makeMenu()
|
|
controller.menuWillOpen(menu)
|
|
let parentKey = ObjectIdentifier(menu)
|
|
controller.openMenus[parentKey] = menu
|
|
controller.menuVersions[parentKey] = controller.menuContentVersion
|
|
|
|
let costItem = try #require(menu.items.first { ($0.representedObject as? String) == "menuCardCost" })
|
|
#expect(costItem.view == nil)
|
|
#expect(costItem.title == StatusItemController.costMenuTitle)
|
|
#expect(costItem.isEnabled)
|
|
let submenu = try #require(costItem.submenu)
|
|
#expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
|
|
#expect(submenu.minimumWidth >= StatusItemController.menuCardBaseWidth)
|
|
#expect(submenu.items.first?.view == nil)
|
|
|
|
controller.menuRefreshEnabledOverrideForTesting = true
|
|
controller.menuWillOpen(submenu)
|
|
let submenuKey = ObjectIdentifier(submenu)
|
|
#expect(controller.openMenus[submenuKey] === submenu)
|
|
#expect(submenu.items.first?.view != nil)
|
|
|
|
let oldParentVersion = try #require(controller.menuVersions[parentKey])
|
|
controller.invalidateMenus(
|
|
refreshOpenMenus: true,
|
|
deferOpenParentMenuRebuild: true)
|
|
#expect(controller.menuVersions[parentKey] == oldParentVersion)
|
|
controller.invalidateMenus(
|
|
refreshOpenMenus: true,
|
|
deferOpenParentMenuRebuild: true)
|
|
#expect(controller.menuVersions[parentKey] == oldParentVersion)
|
|
|
|
controller.menuDidClose(submenu)
|
|
#expect(controller.openMenus[submenuKey] == nil)
|
|
|
|
for _ in 0..<40 where controller.menuVersions[parentKey] != oldParentVersion {
|
|
await Task.yield()
|
|
}
|
|
#expect(controller.menuVersions[parentKey] == oldParentVersion)
|
|
|
|
controller.menuDidClose(menu)
|
|
for _ in 0..<40 where controller.menuVersions[parentKey] != controller.menuContentVersion {
|
|
await Task.yield()
|
|
}
|
|
if controller.menuVersions[parentKey] != controller.menuContentVersion {
|
|
controller.menuWillOpen(menu)
|
|
}
|
|
for _ in 0..<40 where controller.menuVersions[parentKey] != controller.menuContentVersion {
|
|
await Task.yield()
|
|
}
|
|
#expect(controller.menuVersions[parentKey] == controller.menuContentVersion)
|
|
}
|
|
|
|
@Test
|
|
func `open hosted submenu rebuilds from unavailable placeholder when data arrives`() async {
|
|
let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
|
|
StatusItemController.menuCardRenderingEnabled = true
|
|
defer {
|
|
StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
|
|
}
|
|
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = false
|
|
settings.refreshFrequency = .manual
|
|
settings.mergeIcons = true
|
|
settings.selectedMenuProvider = .claude
|
|
settings.costUsageEnabled = true
|
|
Self.enableOnlyClaude(settings)
|
|
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
controller.menuRefreshEnabledOverrideForTesting = true
|
|
|
|
let submenu = controller.makeHostedSubviewPlaceholderMenu(
|
|
chartID: StatusItemController.costHistoryChartID,
|
|
provider: .claude,
|
|
width: StatusItemController.menuCardBaseWidth)
|
|
controller.menuWillOpen(submenu)
|
|
let submenuKey = ObjectIdentifier(submenu)
|
|
#expect(controller.openMenus[submenuKey] === submenu)
|
|
#expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
|
|
#expect(submenu.items.first?.view == nil)
|
|
#expect(submenu.items.first?.title == "No data available")
|
|
|
|
let openedVersion = controller.menuContentVersion
|
|
store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
|
|
controller.invalidateMenus(refreshOpenMenus: true)
|
|
|
|
for _ in 0..<40 {
|
|
if controller.menuContentVersion != openedVersion,
|
|
submenu.items.first?.view != nil
|
|
{
|
|
break
|
|
}
|
|
await Task.yield()
|
|
}
|
|
|
|
#expect(controller.menuContentVersion != openedVersion)
|
|
#expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID)
|
|
#expect(submenu.items.first?.view != nil)
|
|
#expect(submenu.items.first?.title != "No data available")
|
|
}
|
|
|
|
@Test
|
|
func `open hydrated provider submenu preserves identity across refresh`() throws {
|
|
try self.assertHostedSubmenuPreservesIdentity(
|
|
chartID: StatusItemController.costHistoryChartID,
|
|
provider: .claude,
|
|
seed: Self.seedClaudeSnapshots)
|
|
try self.assertHostedSubmenuPreservesIdentity(
|
|
chartID: StatusItemController.costHistoryChartID,
|
|
provider: .openai,
|
|
seed: Self.seedOpenAICostSnapshot)
|
|
try self.assertHostedSubmenuPreservesIdentity(
|
|
chartID: StatusItemController.usageHistoryChartID,
|
|
provider: .claude,
|
|
seed: Self.seedPlanUtilizationHistory)
|
|
try self.assertHostedSubmenuPreservesIdentity(
|
|
chartID: StatusItemController.storageBreakdownID,
|
|
provider: .claude,
|
|
seed: Self.seedStorageFootprint)
|
|
try self.assertHostedSubmenuPreservesIdentity(
|
|
chartID: StatusItemController.zaiHourlyUsageChartID,
|
|
provider: .zai,
|
|
seed: Self.seedZaiHourlyUsage)
|
|
}
|
|
|
|
@Test
|
|
func `hosted chart items size to the displayed view without a throwaway controller`() throws {
|
|
try self.assertHostedChartItemHeightMatchesRefresh(
|
|
chartID: StatusItemController.costHistoryChartID,
|
|
provider: .claude,
|
|
seed: Self.seedClaudeSnapshots)
|
|
{ controller, submenu, width in
|
|
controller.appendCostHistoryChartItem(to: submenu, provider: .claude, width: width)
|
|
}
|
|
try self.assertHostedChartItemHeightMatchesRefresh(
|
|
chartID: StatusItemController.usageHistoryChartID,
|
|
provider: .claude,
|
|
seed: Self.seedPlanUtilizationHistory)
|
|
{ controller, submenu, width in
|
|
controller.appendUsageHistoryChartItem(to: submenu, provider: .claude, width: width)
|
|
}
|
|
try self.assertHostedChartItemHeightMatchesRefresh(
|
|
chartID: StatusItemController.storageBreakdownID,
|
|
provider: .claude,
|
|
seed: Self.seedStorageFootprint)
|
|
{ controller, submenu, width in
|
|
controller.appendStorageBreakdownItem(to: submenu, provider: .claude, width: width)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
func `zai chart render signature follows time range boundaries`() throws {
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "yyyy-MM-dd HH:mm"
|
|
formatter.locale = Locale(identifier: "en_US_POSIX")
|
|
let beforeMidnight = try #require(formatter.date(from: "2026-01-01 23:30"))
|
|
let afterMidnight = try #require(formatter.date(from: "2026-01-02 00:30"))
|
|
let modelUsage = ZaiModelUsageData(
|
|
xTime: ["2026-01-01 23:00"],
|
|
modelDataList: [
|
|
ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [100]),
|
|
])
|
|
|
|
let before = StatusItemController.zaiHourlyUsageRenderSignature(
|
|
modelUsage: modelUsage,
|
|
now: beforeMidnight)
|
|
let after = StatusItemController.zaiHourlyUsageRenderSignature(
|
|
modelUsage: modelUsage,
|
|
now: afterMidnight)
|
|
|
|
#expect(before != after)
|
|
}
|
|
|
|
@Test
|
|
func `utilization chart invalidates when active account changes`() throws {
|
|
let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
|
|
StatusItemController.menuCardRenderingEnabled = true
|
|
defer { StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering }
|
|
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = false
|
|
settings.refreshFrequency = .manual
|
|
Self.enableOnlyClaude(settings)
|
|
settings.addTokenAccount(provider: .claude, label: "Alice", token: "alice-token")
|
|
settings.addTokenAccount(provider: .claude, label: "Bob", token: "bob-token")
|
|
let accounts = settings.tokenAccounts(for: .claude)
|
|
let alice = try #require(accounts.first)
|
|
let bob = try #require(accounts.last)
|
|
let aliceKey = try #require(
|
|
UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: alice))
|
|
let bobKey = try #require(
|
|
UsageStore._planUtilizationTokenAccountKeyForTesting(provider: .claude, account: bob))
|
|
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
Self.seedClaudeSnapshots(in: store)
|
|
store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(accounts: [
|
|
aliceKey: [Self.makePlanHistory(usedPercent: 20)],
|
|
bobKey: [Self.makePlanHistory(usedPercent: 50)],
|
|
])
|
|
settings.setActiveTokenAccountIndex(0, for: .claude)
|
|
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let submenu = controller.makeHostedSubviewPlaceholderMenu(
|
|
chartID: StatusItemController.usageHistoryChartID,
|
|
provider: .claude,
|
|
width: StatusItemController.menuCardBaseWidth)
|
|
controller.menuWillOpen(submenu)
|
|
let aliceView = try #require(submenu.items.first?.view)
|
|
|
|
settings.setActiveTokenAccountIndex(1, for: .claude)
|
|
controller.refreshHostedSubviewMenu(submenu)
|
|
|
|
let bobView = try #require(submenu.items.first?.view)
|
|
#expect(bobView !== aliceView)
|
|
}
|
|
|
|
private func assertHostedChartItemHeightMatchesRefresh(
|
|
chartID: String,
|
|
provider: UsageProvider,
|
|
seed: (UsageStore) -> Void,
|
|
append: (StatusItemController, NSMenu, CGFloat) -> Bool) throws
|
|
{
|
|
let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
|
|
StatusItemController.menuCardRenderingEnabled = true
|
|
defer { StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering }
|
|
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = false
|
|
settings.refreshFrequency = .manual
|
|
settings.costUsageEnabled = true
|
|
settings.providerStorageFootprintsEnabled = true
|
|
Self.enableOnly(settings, provider: provider)
|
|
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
seed(store)
|
|
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
|
|
let width = StatusItemController.menuCardBaseWidth
|
|
let submenu = NSMenu()
|
|
submenu.minimumWidth = width
|
|
#expect(append(controller, submenu, width))
|
|
|
|
let item = try #require(submenu.items.first)
|
|
let view = try #require(item.view)
|
|
let heightFromAppend = view.frame.height
|
|
// The height the append path assigns must match the authoritative re-measure pass; otherwise
|
|
// dropping the throwaway NSHostingController would have changed sizing behavior.
|
|
controller.refreshHostedSubviewHeights(in: submenu)
|
|
#expect(view.frame.height == heightFromAppend)
|
|
#expect(heightFromAppend > 1)
|
|
}
|
|
|
|
private func assertHostedSubmenuPreservesIdentity(
|
|
chartID: String,
|
|
provider: UsageProvider,
|
|
seed: (UsageStore) -> Void) throws
|
|
{
|
|
let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled
|
|
StatusItemController.menuCardRenderingEnabled = true
|
|
defer {
|
|
StatusItemController.menuCardRenderingEnabled = previousMenuCardRendering
|
|
}
|
|
|
|
let settings = Self.makeSettings()
|
|
settings.statusChecksEnabled = false
|
|
settings.refreshFrequency = .manual
|
|
settings.mergeIcons = true
|
|
settings.selectedMenuProvider = provider
|
|
settings.costUsageEnabled = true
|
|
settings.providerStorageFootprintsEnabled = true
|
|
Self.enableOnly(settings, provider: provider)
|
|
|
|
let fetcher = UsageFetcher()
|
|
let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings)
|
|
seed(store)
|
|
|
|
let controller = StatusItemController(
|
|
store: store,
|
|
settings: settings,
|
|
account: fetcher.loadAccountInfo(),
|
|
updater: DisabledUpdaterController(),
|
|
preferencesSelection: PreferencesSelection(),
|
|
statusBar: .system)
|
|
defer { controller.releaseStatusItemsForTesting() }
|
|
controller.menuRefreshEnabledOverrideForTesting = true
|
|
|
|
let submenu = controller.makeHostedSubviewPlaceholderMenu(
|
|
chartID: chartID,
|
|
provider: provider,
|
|
width: StatusItemController.menuCardBaseWidth)
|
|
controller.menuWillOpen(submenu)
|
|
|
|
let hydratedItem = try #require(submenu.items.first)
|
|
#expect(hydratedItem.representedObject as? String == chartID)
|
|
#expect(hydratedItem.toolTip == provider.rawValue)
|
|
#expect(hydratedItem.view != nil)
|
|
#expect(hydratedItem.title != "No data available")
|
|
let hydratedView = hydratedItem.view
|
|
let inflatedHeight = hydratedView.map { view -> CGFloat in
|
|
let inflatedHeight = view.frame.height + 100
|
|
if chartID == StatusItemController.zaiHourlyUsageChartID {
|
|
view.frame.size.height = inflatedHeight
|
|
}
|
|
return inflatedHeight
|
|
}
|
|
|
|
controller.refreshHostedSubviewMenu(submenu)
|
|
|
|
let refreshedItem = try #require(submenu.items.first)
|
|
#expect(refreshedItem.representedObject as? String == chartID)
|
|
#expect(refreshedItem.toolTip == provider.rawValue)
|
|
#expect(refreshedItem.view != nil)
|
|
#expect(refreshedItem.title != "No data available")
|
|
#expect(refreshedItem.view === hydratedView)
|
|
if chartID == StatusItemController.zaiHourlyUsageChartID {
|
|
#expect(refreshedItem.view?.frame.height != inflatedHeight)
|
|
}
|
|
|
|
if chartID == StatusItemController.costHistoryChartID, provider == .claude {
|
|
store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(dailyCost: 2.34), provider: .claude)
|
|
controller.refreshHostedSubviewMenu(submenu)
|
|
|
|
let changedItem = try #require(submenu.items.first)
|
|
#expect(changedItem.view != nil)
|
|
#expect(changedItem.view !== hydratedView)
|
|
}
|
|
}
|
|
|
|
private static func makeSettings() -> SettingsStore {
|
|
let suite = "StatusMenuHostedSubmenuRefreshTests-\(UUID().uuidString)"
|
|
let defaults = UserDefaults(suiteName: suite)!
|
|
defaults.removePersistentDomain(forName: suite)
|
|
return SettingsStore(
|
|
userDefaults: defaults,
|
|
configStore: testConfigStore(suiteName: suite),
|
|
zaiTokenStore: NoopZaiTokenStore(),
|
|
syntheticTokenStore: NoopSyntheticTokenStore())
|
|
}
|
|
|
|
private static func enableOnlyClaude(_ settings: SettingsStore) {
|
|
self.enableOnly(settings, provider: .claude)
|
|
}
|
|
|
|
private static func enableOnly(_ settings: SettingsStore, provider enabledProvider: UsageProvider) {
|
|
let registry = ProviderRegistry.shared
|
|
for provider in UsageProvider.allCases {
|
|
guard let metadata = registry.metadata[provider] else { continue }
|
|
settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == enabledProvider)
|
|
}
|
|
}
|
|
|
|
private static func seedClaudeSnapshots(in store: UsageStore) {
|
|
let snapshot = UsageSnapshot(
|
|
primary: RateWindow(usedPercent: 10, windowMinutes: 300, resetsAt: nil, resetDescription: nil),
|
|
secondary: nil,
|
|
tertiary: nil,
|
|
updatedAt: Date(),
|
|
identity: ProviderIdentitySnapshot(
|
|
providerID: .claude,
|
|
accountEmail: "user@example.com",
|
|
accountOrganization: nil,
|
|
loginMethod: "Team"))
|
|
store._setSnapshotForTesting(snapshot, provider: .claude)
|
|
store._setTokenSnapshotForTesting(Self.makeTokenSnapshot(), provider: .claude)
|
|
}
|
|
|
|
private static func seedOpenAICostSnapshot(in store: UsageStore) {
|
|
let day = Date(timeIntervalSince1970: 1_700_000_000)
|
|
let apiUsage = OpenAIAPIUsageSnapshot(
|
|
daily: [
|
|
OpenAIAPIUsageSnapshot.DailyBucket(
|
|
day: "2025-12-23",
|
|
startTime: day,
|
|
endTime: day.addingTimeInterval(86400),
|
|
costUSD: 1.23,
|
|
requests: 12,
|
|
inputTokens: 100,
|
|
cachedInputTokens: 20,
|
|
outputTokens: 40,
|
|
totalTokens: 160,
|
|
lineItems: [],
|
|
models: []),
|
|
],
|
|
updatedAt: Date(timeIntervalSince1970: 1_700_086_400))
|
|
let snapshot = UsageSnapshot(
|
|
primary: nil,
|
|
secondary: nil,
|
|
tertiary: nil,
|
|
openAIAPIUsage: apiUsage,
|
|
updatedAt: Date(timeIntervalSince1970: 1_700_086_400),
|
|
identity: ProviderIdentitySnapshot(
|
|
providerID: .openai,
|
|
accountEmail: "openai@example.com",
|
|
accountOrganization: nil,
|
|
loginMethod: "API"))
|
|
store._setSnapshotForTesting(snapshot, provider: .openai)
|
|
}
|
|
|
|
private static func seedPlanUtilizationHistory(in store: UsageStore) {
|
|
self.seedClaudeSnapshots(in: store)
|
|
store.planUtilizationHistory[.claude] = PlanUtilizationHistoryBuckets(
|
|
unscoped: [
|
|
self.makePlanHistory(usedPercent: 24),
|
|
])
|
|
}
|
|
|
|
private static func makePlanHistory(usedPercent: Double) -> PlanUtilizationSeriesHistory {
|
|
PlanUtilizationSeriesHistory(
|
|
name: .session,
|
|
windowMinutes: 300,
|
|
entries: [
|
|
PlanUtilizationHistoryEntry(
|
|
capturedAt: Date(timeIntervalSince1970: 1_700_000_000),
|
|
usedPercent: usedPercent,
|
|
resetsAt: Date(timeIntervalSince1970: 1_700_018_000)),
|
|
])
|
|
}
|
|
|
|
private static func seedStorageFootprint(in store: UsageStore) {
|
|
let root = "/Users/test/.claude"
|
|
store.providerStorageFootprints[.claude] = ProviderStorageFootprint(
|
|
provider: .claude,
|
|
totalBytes: 1024,
|
|
paths: [root],
|
|
missingPaths: [],
|
|
unreadablePaths: [],
|
|
components: [.init(path: "\(root)/projects", totalBytes: 1024)],
|
|
updatedAt: Date(timeIntervalSince1970: 1_700_000_000))
|
|
}
|
|
|
|
private static func seedZaiHourlyUsage(in store: UsageStore) {
|
|
let modelUsage = ZaiModelUsageData(
|
|
xTime: ["2026-05-26 00:00"],
|
|
modelDataList: [
|
|
ZaiModelDataItem(modelName: "glm-4.5", tokensUsage: [512]),
|
|
])
|
|
let snapshot = UsageSnapshot(
|
|
primary: nil,
|
|
secondary: nil,
|
|
tertiary: nil,
|
|
zaiUsage: ZaiUsageSnapshot(
|
|
tokenLimit: nil,
|
|
timeLimit: nil,
|
|
planName: "Pro",
|
|
modelUsage: modelUsage,
|
|
updatedAt: Date(timeIntervalSince1970: 1_700_000_000)),
|
|
updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
|
|
identity: ProviderIdentitySnapshot(
|
|
providerID: .zai,
|
|
accountEmail: "zai@example.com",
|
|
accountOrganization: nil,
|
|
loginMethod: "OAuth"))
|
|
store._setSnapshotForTesting(snapshot, provider: .zai)
|
|
}
|
|
|
|
private static func makeTokenSnapshot(
|
|
dailyCost: Double = 1.23,
|
|
projectSourcePath: String? = nil) -> CostUsageTokenSnapshot
|
|
{
|
|
let projects = projectSourcePath.map { sourcePath in
|
|
[
|
|
CostUsageProjectBreakdown(
|
|
name: "Project",
|
|
path: "/tmp/main",
|
|
totalTokens: 123,
|
|
totalCostUSD: dailyCost,
|
|
daily: [],
|
|
modelBreakdowns: nil,
|
|
sources: [
|
|
CostUsageProjectSourceBreakdown(
|
|
name: "Source",
|
|
path: sourcePath,
|
|
totalTokens: 123,
|
|
totalCostUSD: dailyCost,
|
|
daily: [],
|
|
modelBreakdowns: nil),
|
|
]),
|
|
]
|
|
} ?? []
|
|
return CostUsageTokenSnapshot(
|
|
sessionTokens: 123,
|
|
sessionCostUSD: 0.12,
|
|
last30DaysTokens: 123,
|
|
last30DaysCostUSD: dailyCost,
|
|
daily: [
|
|
CostUsageDailyReport.Entry(
|
|
date: "2025-12-23",
|
|
inputTokens: nil,
|
|
outputTokens: nil,
|
|
totalTokens: 123,
|
|
costUSD: dailyCost,
|
|
modelsUsed: nil,
|
|
modelBreakdowns: nil),
|
|
],
|
|
projects: projects,
|
|
updatedAt: Date())
|
|
}
|
|
}
|