Skip to content

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

fix: 同步服务状态刷新并精简回归测试

Bob68757e017be3
diff --git a/CodexBar/App/CodexBarAppDelegate.swift b/CodexBar/App/CodexBarAppDelegate.swift
index e93736c..88bf64d 100644
--- a/CodexBar/App/CodexBarAppDelegate.swift
+++ b/CodexBar/App/CodexBarAppDelegate.swift
@@ -6,7 +6,7 @@ import os
final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {
private lazy var codexStatusService = CodexStatusService(startup: appServerStartup)
private lazy var appServerStartup = AppServerStartup()
- lazy var viewModel = CodexStatusViewModel(service: codexStatusService)
+ lazy var viewModel = CodexStatusViewModel(service: codexStatusService, serviceStatusMonitor: serviceStatusMonitor)
let historyViewModel = HistoryViewModel()
lazy var tuiNotificationSettings = TUINotificationSettings(
codexStatusService: codexStatusService
diff --git a/CodexBar/Controllers/StatusItemController.swift b/CodexBar/Controllers/StatusItemController.swift
index b2e789c..362bfe6 100644
--- a/CodexBar/Controllers/StatusItemController.swift
+++ b/CodexBar/Controllers/StatusItemController.swift
@@ -157,7 +157,7 @@ final class StatusItemController: NSObject, NSMenuDelegate {
func uninstall() {
closeMenuSurface(animated: false)
- serviceStatusMonitor.setActive(false, refreshInterval: .seconds(viewModel.dataUpdateInterval.duration))
+ serviceStatusMonitor.setEnabled(false)
auxiliaryWindowFocusRestoreTask?.cancel()
statusIconExpirationTask?.cancel()
statusIconHostingView?.removeFromSuperview()
@@ -274,18 +274,17 @@ final class StatusItemController: NSObject, NSMenuDelegate {
// MARK: - 订阅与全局快捷键
private func observeViewModel() {
- Publishers.CombineLatest3(
- menuSurfaceVisibility.$isVisible,
- mainPanelSettings.$layout,
- viewModel.$dataUpdateInterval
- )
- .sink { [weak self] isVisible, layout, interval in
- self?.serviceStatusMonitor.setActive(
- isVisible && layout.isVisible(.serviceStatus),
- refreshInterval: .seconds(interval.duration)
- )
- }
- .store(in: &cancellables)
+ mainPanelSettings.$layout
+ .map { $0.isVisible(.serviceStatus) }
+ .removeDuplicates()
+ .sink { [weak self] isEnabled in
+ guard let self else { return }
+ serviceStatusMonitor.setEnabled(isEnabled)
+ if isEnabled, viewModel.isRefreshing || viewModel.autoRefreshCountdownStartedAt != nil {
+ viewModel.refreshAfterCurrent(trigger: .settings)
+ }
+ }
+ .store(in: &cancellables)
let hasTaskCenterContent = activityMonitor.$snapshot
.map(\.hasTaskCenterContent)
diff --git a/CodexBar/Services/CodexStatus/CodexServiceStatusMonitor.swift b/CodexBar/Services/CodexStatus/CodexServiceStatusMonitor.swift
index efc60cc..2287fe3 100644
--- a/CodexBar/Services/CodexStatus/CodexServiceStatusMonitor.swift
+++ b/CodexBar/Services/CodexStatus/CodexServiceStatusMonitor.swift
@@ -11,21 +11,15 @@ final class CodexServiceStatusMonitor: ObservableObject {
@Published private(set) var state: State = .checking
private let fetch: @Sendable () async throws -> CodexServiceStatus
- private var refreshInterval: Duration
+ private var isEnabled = false
private var refreshTask: Task<Void, Never>?
- private var lastRefresh: ContinuousClock.Instant?
-
- private var nextRefresh: ContinuousClock.Instant? {
- lastRefresh?.advanced(by: refreshInterval)
- }
convenience init() {
let service = CodexServiceStatusService()
self.init(fetch: { try await service.fetch() })
}
- init(refreshInterval: Duration = .seconds(60), fetch: @escaping @Sendable () async throws -> CodexServiceStatus) {
- self.refreshInterval = refreshInterval
+ init(fetch: @escaping @Sendable () async throws -> CodexServiceStatus) {
self.fetch = fetch
}
@@ -33,39 +27,30 @@ final class CodexServiceStatusMonitor: ObservableObject {
refreshTask?.cancel()
}
- func setActive(_ active: Bool, refreshInterval: Duration) {
- let intervalChanged = self.refreshInterval != refreshInterval
- self.refreshInterval = refreshInterval
- if !active || intervalChanged {
+ func setEnabled(_ enabled: Bool) {
+ isEnabled = enabled
+ if !enabled {
refreshTask?.cancel()
refreshTask = nil
}
- guard active, refreshTask == nil else { return }
- if nextRefresh.map({ $0 <= .now }) ?? true {
- state = .checking
- }
- refreshTask = Task { [weak self] in
- while !Task.isCancelled {
- if let deadline = self?.nextRefresh {
- do { try await Task.sleep(until: deadline, clock: ContinuousClock()) } catch { return }
+ }
+
+ func refresh() async {
+ guard isEnabled, !Task.isCancelled else { return }
+ if refreshTask == nil {
+ refreshTask = Task { [weak self, fetch] in
+ let result: State
+ do {
+ result = try await .available(fetch())
+ } catch {
+ result = .unavailable
}
+ // 关闭分区后取消的旧请求不能覆盖重新启用后的结果
guard !Task.isCancelled, let self else { return }
- await refresh()
+ state = result
+ refreshTask = nil
}
}
- }
-
- private func refresh() async {
- do {
- let status = try await fetch()
- try Task.checkCancellation()
- lastRefresh = .now
- state = .available(status)
- } catch {
- // 隐藏后取消的旧请求不能覆盖重开面板后的结果
- guard !Task.isCancelled else { return }
- lastRefresh = .now
- state = .unavailable
- }
+ await refreshTask?.value
}
}
diff --git a/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift b/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift
index 4501606..4459608 100644
--- a/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift
+++ b/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift
@@ -69,6 +69,7 @@ final class CodexStatusViewModel: ObservableObject {
}
private let service: CodexStatusService
+ private let serviceStatusMonitor: CodexServiceStatusMonitor?
private let defaults: UserDefaults
private var autoRefreshTask: Task<Void, Never>?
private var pendingRefreshTask: Task<Void, Never>?
@@ -79,8 +80,13 @@ final class CodexStatusViewModel: ObservableObject {
private let refreshCoordinator = RefreshTaskCoordinator()
private var connectionInfoGeneration: UInt64 = 0
- init(service: CodexStatusService = CodexStatusService(), defaults: UserDefaults = .standard) {
+ init(
+ service: CodexStatusService = CodexStatusService(),
+ serviceStatusMonitor: CodexServiceStatusMonitor? = nil,
+ defaults: UserDefaults = .standard
+ ) {
self.service = service
+ self.serviceStatusMonitor = serviceStatusMonitor
self.defaults = defaults
dataUpdateInterval = (defaults.object(forKey: Self.dataUpdateIntervalKey) as? Int)
.flatMap(DataUpdateInterval.init(rawValue:)) ?? .oneMinute
@@ -159,11 +165,15 @@ final class CodexStatusViewModel: ObservableObject {
refreshCoordinator.run(
setRefreshing: { [weak self] in self?.setRefreshing($0) },
- operation: { [service = self.service] in
- await (
+ operation: { [service = self.service, serviceStatusMonitor = self.serviceStatusMonitor] in
+ // 账户推送只更新局部数据, 普通刷新等待服务状态后统一推进更新时间
+ async let serviceStatus: Void? = trigger == .accountNotification ? nil : serviceStatusMonitor?.refresh()
+ let result = await (
fetch: service.fetchOutcome(),
connectionInfo: service.currentConnectionInfo()
)
+ await serviceStatus
+ return result
},
commit: { [weak self] result in
guard let self else {
diff --git a/CodexBar/Views/Menu/CodexStatusMenuSections.swift b/CodexBar/Views/Menu/CodexStatusMenuSections.swift
index 9f725ab..6a5fc88 100644
--- a/CodexBar/Views/Menu/CodexStatusMenuSections.swift
+++ b/CodexBar/Views/Menu/CodexStatusMenuSections.swift
@@ -275,8 +275,7 @@ struct QuotaLimitsSection: View {
/// 底部更新时间行, 同时承载 Sparkle 被动更新提示
struct UpdatedAtRow: View {
@Environment(\.mainPanelAnimationsEnabled) private var allowsAnimations
- let snapshot: CodexQuotaSnapshot
- let countdownStartedAt: Date
+ let updatedAt: Date
let countdownInterval: TimeInterval
let isCountdownActive: Bool
let syncDisplayState: SyncDisplayState
@@ -287,7 +286,7 @@ struct UpdatedAtRow: View {
HStack {
HStack(spacing: MenuMetrics.statusIconSpacing) {
AutoRefreshCountdownTimeline(
- startedAt: countdownStartedAt,
+ startedAt: updatedAt,
interval: countdownInterval,
isActive: isCountdownActive,
color: .blue
@@ -297,14 +296,14 @@ struct UpdatedAtRow: View {
Text("usage.status.last-updated")
.foregroundStyle(Self.secondaryTextColor)
- Text(Self.timeFormatter.string(from: snapshot.generatedAt))
+ Text(Self.timeFormatter.string(from: updatedAt))
.monospacedDigit()
- .numericTransition(value: snapshot.generatedAt, comparison: snapshot.generatedAt.timeIntervalSinceReferenceDate, enabled: allowsAnimations)
+ .numericTransition(value: updatedAt, comparison: updatedAt.timeIntervalSinceReferenceDate, enabled: allowsAnimations)
.foregroundStyle(Self.secondaryTextColor)
}
}
.font(.caption2)
- .animation(Metrics.statusAnimation, value: snapshot.generatedAt)
+ .animation(Metrics.statusAnimation, value: updatedAt)
Spacer()
diff --git a/CodexBar/Views/Menu/CodexStatusMenuView.swift b/CodexBar/Views/Menu/CodexStatusMenuView.swift
index 98f4dc2..b05f169 100644
--- a/CodexBar/Views/Menu/CodexStatusMenuView.swift
+++ b/CodexBar/Views/Menu/CodexStatusMenuView.swift
@@ -272,8 +272,7 @@ private extension CodexStatusMenuView {
func updatedAtRow(for snapshot: CodexQuotaSnapshot) -> some View {
UpdatedAtRow(
- snapshot: snapshot,
- countdownStartedAt: viewModel.autoRefreshCountdownStartedAt ?? snapshot.generatedAt,
+ updatedAt: viewModel.autoRefreshCountdownStartedAt ?? snapshot.generatedAt,
countdownInterval: viewModel.autoRefreshInterval,
isCountdownActive: menuSurfaceVisibility.isVisible,
syncDisplayState: SyncDisplayState(
diff --git a/Tests/App/Activity/ActivitySchedulingTests.swift b/Tests/App/Activity/ActivitySchedulingTests.swift
index e8c91b8..46a4310 100644
--- a/Tests/App/Activity/ActivitySchedulingTests.swift
+++ b/Tests/App/Activity/ActivitySchedulingTests.swift
@@ -66,23 +66,29 @@ struct ActivitySchedulingTests {
try peer.send(["method": "thread/tokenUsage/updated", "params": ["threadId": "thread", "turnId": "turn", "tokenUsage": ["total": tokenUsage, "last": tokenUsage]]])
}
try peer.send(["method": "thread/status/changed", "params": ["threadId": "thread", "status": 123]])
+ // 后续通知作为处理屏障, 避免在畸形消息被消费前结束测试
+ try peer.send(["method": "account/updated", "params": [:]])
_ = release.wait(timeout: .now() + 5)
}
defer { server.close() }
var failed = false
+ var receivedFollowup = false
let store = TokenUsageHistoryStore(directoryURL: directory.url)
let reader = AppServerActivityReader(
probe: ActivityReaderProbe(), socketURL: server.url,
- tokenUsageHistory: store, activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url)
- ) {
- if case .sourceUnavailable = $0.phase {
- failed = true
+ tokenUsageHistory: store, activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url),
+ onAccountChange: { _ in receivedFollowup = true },
+ onBatch: {
+ if case .sourceUnavailable = $0.phase {
+ failed = true
+ }
}
- }
+ )
await reader.start()
- for _ in 0 ..< 200 where !failed {
+ for _ in 0 ..< 200 where !receivedFollowup && !failed {
try await Task.sleep(for: .milliseconds(5))
}
+ #expect(receivedFollowup)
#expect(!failed)
await reader.stop()
#expect(try await store.refresh().first?.tokenUsage.totalTokens == 50)
diff --git a/Tests/App/Activity/ActivityTaskTests.swift b/Tests/App/Activity/ActivityTaskTests.swift
index 43515c3..fbd86be 100644
--- a/Tests/App/Activity/ActivityTaskTests.swift
+++ b/Tests/App/Activity/ActivityTaskTests.swift
@@ -529,10 +529,6 @@ struct ActivityTaskTests {
return monitor
}
- private nonisolated func makeStatusService(suiteName: String) -> CodexStatusService {
- CodexStatusService(socketURL: URL(fileURLWithPath: "/tmp/\(suiteName).sock"))
- }
-
@Test func subagentCountDeduplicatesAndRejectsOlderEvents() {
var task = makeTask()
#expect(task.snapshot.activeSubagentCount == nil)
diff --git a/Tests/App/Activity/ActivityTokenUsageTests.swift b/Tests/App/Activity/ActivityTokenUsageTests.swift
index d631c78..1d54101 100644
--- a/Tests/App/Activity/ActivityTokenUsageTests.swift
+++ b/Tests/App/Activity/ActivityTokenUsageTests.swift
@@ -142,26 +142,22 @@ struct ActivityTokenUsageTests {
}
@Test func activeUsageDoesNotCarryAcrossTurnsOrKeepUnavailableData() throws {
- let directory = try TestDirectory()
- defer { try? directory.remove() }
- let preferences = try TestPreferences()
- defer { preferences.remove() }
- let monitor = try makeMonitor(directory: directory, preferences: preferences)
+ var graph = ActivityTaskGraph()
let event = TestFixtures.event(turn: "turn-b")
let key = try #require(ActivityTaskKey(event: event))
- monitor.graph.tasks[key] = ActivityTask(
+ graph.tasks[key] = ActivityTask(
displayID: UUID(), key: key, event: event, state: .running,
startedAt: TestFixtures.now, progressGeneration: 1
)
- monitor.graph.applyActiveTokenUsage([state(reference("thread-a", "turn-a"))])
- #expect(monitor.graph.tasks[key]?.tokenUsage == nil)
+ graph.applyActiveTokenUsage([state(reference("thread-a", "turn-a"))])
+ #expect(graph.tasks[key]?.tokenUsage == nil)
var current = state(reference("thread-a", "turn-b"), terminal: nil)
current.rootTurnID = "turn-b"
- monitor.graph.applyActiveTokenUsage([current])
- #expect(monitor.graph.tasks[key]?.tokenUsage?.totalTokens == 110)
+ graph.applyActiveTokenUsage([current])
+ #expect(graph.tasks[key]?.tokenUsage?.totalTokens == 110)
current.readStatus = .unavailable
- monitor.graph.applyActiveTokenUsage([current])
- #expect(monitor.graph.tasks[key]?.tokenUsage == nil)
+ graph.applyActiveTokenUsage([current])
+ #expect(graph.tasks[key]?.tokenUsage == nil)
}
@Test func overflowIsRejectedAndConfirmedZeroRemainsAvailable() {
@@ -244,11 +240,7 @@ struct ActivityTokenUsageTests {
}
@Test func laterTurnPendingAgentMustNotEraseCompletedTurnUsage() throws {
- let directory = try TestDirectory()
- defer { try? directory.remove() }
- let preferences = try TestPreferences()
- defer { preferences.remove() }
- let monitor = try makeMonitor(directory: directory, preferences: preferences)
+ var graph = ActivityTaskGraph()
let first = TestFixtures.event()
let firstKey = try #require(ActivityTaskKey(event: first))
let task = ActivityTask(
@@ -256,32 +248,32 @@ struct ActivityTokenUsageTests {
startedAt: TestFixtures.now, progressGeneration: 1
)
var transitions: [ActivityTransition] = []
- monitor.graph.resolveTerminal(.completed(at: TestFixtures.now, duration: 1), task: task, key: firstKey, abortFallback: TestFixtures.now, into: &transitions)
+ graph.resolveTerminal(.completed(at: TestFixtures.now, duration: 1), task: task, key: firstKey, abortFallback: TestFixtures.now, into: &transitions)
let firstState = state(reference("thread-a", "turn-a"))
- monitor.graph.applyTerminalTokenUsage([firstState])
- #expect(monitor.graph.completions.first?.tokenUsage?.totalTokens == 110)
+ graph.applyTerminalTokenUsage([firstState])
+ #expect(graph.completions.first?.tokenUsage?.totalTokens == 110)
let second = TestFixtures.event(at: TestFixtures.now.addingTimeInterval(2), turn: "turn-b")
let secondKey = try #require(ActivityTaskKey(event: second))
- monitor.graph.tasks[secondKey] = ActivityTask(
+ graph.tasks[secondKey] = ActivityTask(
displayID: UUID(), key: secondKey, event: second, state: .running,
startedAt: second.timestamp, progressGeneration: 2
)
let child = TestFixtures.event(.subagentStarted, at: TestFixtures.now.addingTimeInterval(3), turn: "child-turn-b", agentThreadID: "child-b")
- let observedResult11 = monitor.graph.deferUnassociatedSubagentEvent(child, source: .live)
+ let observedResult11 = graph.deferUnassociatedSubagentEvent(child, source: .live)
#expect(observedResult11)
- monitor.graph.applyTerminalTokenUsage([firstState])
- #expect(monitor.graph.completions.first?.tokenUsage?.totalTokens == 110)
+ graph.applyTerminalTokenUsage([firstState])
+ #expect(graph.completions.first?.tokenUsage?.totalTokens == 110)
let lateChild = reference("child-a", "child-turn-a")
- monitor.graph.subagentTurnLinks[lateChild] = (firstKey, TestFixtures.now)
- monitor.graph.applyTerminalTokenUsage([firstState])
- #expect(monitor.graph.completions.first?.tokenUsage?.totalTokens == 110)
- monitor.graph.applyTerminalTokenUsage([firstState, state(lateChild, input: 200)])
- #expect(monitor.graph.completions.first?.tokenUsage?.totalTokens == 320)
+ graph.subagentTurnLinks[lateChild] = (firstKey, TestFixtures.now)
+ graph.applyTerminalTokenUsage([firstState])
+ #expect(graph.completions.first?.tokenUsage?.totalTokens == 110)
+ graph.applyTerminalTokenUsage([firstState, state(lateChild, input: 200)])
+ #expect(graph.completions.first?.tokenUsage?.totalTokens == 320)
var unavailable = firstState
unavailable.readStatus = .unavailable
- monitor.graph.applyTerminalTokenUsage([unavailable])
- _ = monitor.graph.terminalTokenUsageReferences()
- #expect(monitor.graph.completions.first?.tokenUsage?.totalTokens == 320)
+ graph.applyTerminalTokenUsage([unavailable])
+ _ = graph.terminalTokenUsageReferences()
+ #expect(graph.completions.first?.tokenUsage?.totalTokens == 320)
}
@Test(arguments: [false, true])
@@ -326,16 +318,8 @@ struct ActivityTokenUsageTests {
@Test(arguments: [false, true])
func liveTerminalPresentationPreservesInterruptBehavior(interrupted: Bool) throws {
- let directory = try TestDirectory()
- defer { try? directory.remove() }
- let preferences = try TestPreferences()
- defer { preferences.remove() }
- let monitor = try makeMonitor(directory: directory, preferences: preferences)
- monitor.isActivitySourceHealthy = true
- monitor.isProtectionRecoveryInProgress = false
+ var graph = ActivityTaskGraph()
let now = Date()
- monitor.turnTransitionNotBefore = now.addingTimeInterval(-1)
- monitor.terminalPresentationNotBefore = now.addingTimeInterval(-1)
let event = TestFixtures.event(.turnAborted, at: now)
let key = try #require(ActivityTaskKey(event: event))
let task = ActivityTask(
@@ -344,21 +328,21 @@ struct ActivityTokenUsageTests {
)
var transitions: [ActivityTransition] = []
if interrupted {
- monitor.graph.tasks[key] = task
- monitor.graph.finishTask(from: event, source: .live, into: &transitions)
- monitor.graph.finishTask(from: event, source: .live, into: &transitions)
- #expect(monitor.graph.tasks.isEmpty)
- #expect(monitor.graph.terminations.count == 1)
+ graph.tasks[key] = task
+ graph.finishTask(from: event, source: .live, into: &transitions)
+ graph.finishTask(from: event, source: .live, into: &transitions)
+ #expect(graph.tasks.isEmpty)
+ #expect(graph.terminations.count == 1)
} else {
- monitor.graph.resolveTerminal(
+ graph.resolveTerminal(
.completed(at: now, duration: 1), task: task, key: key,
abortFallback: now, into: &transitions
)
- #expect(monitor.graph.completions.count == 1)
+ #expect(graph.completions.count == 1)
}
#expect(transitions.count == (interrupted ? 0 : 1))
- #expect(monitor.graph.terminalEvents.count == 1)
- #expect(monitor.graph.terminalTokenUsageRequests.count == 1)
+ #expect(graph.terminalEvents.count == 1)
+ #expect(graph.terminalTokenUsageRequests.count == 1)
}
@Test(arguments: [ActivityTaskState.running, .waitingApproval])
@@ -443,19 +427,11 @@ struct ActivityTokenUsageTests {
protectionStore: ProtectionStore(directoryURL: directory.url)
)
}
-
- private nonisolated func makeStatusService(suiteName: String) -> CodexStatusService {
- CodexStatusService(socketURL: URL(fileURLWithPath: "/tmp/\(suiteName).sock"))
- }
}
extension ActivityTokenUsageTests {
@Test func unknownCompletionTimeDoesNotInventDurationOrRepeatCompletion() throws {
- let directory = try TestDirectory()
- defer { try? directory.remove() }
- let preferences = try TestPreferences()
- defer { preferences.remove() }
- let monitor = try makeMonitor(directory: directory, preferences: preferences)
+ var graph = ActivityTaskGraph()
let now = Date()
let event = TestFixtures.event(at: now.addingTimeInterval(-60))
let key = try #require(ActivityTaskKey(event: event))
@@ -468,7 +444,7 @@ extension ActivityTokenUsageTests {
progressGeneration: 1
)
var transitions: [ActivityTransition] = []
- monitor.graph.resolveTerminal(
+ graph.resolveTerminal(
.completed(at: nil, duration: nil),
task: task,
key: key,
@@ -476,15 +452,15 @@ extension ActivityTokenUsageTests {
publishesEvents: false,
into: &transitions
)
- monitor.graph.resolveTerminal(
+ graph.resolveTerminal(
.completed(at: now.addingTimeInterval(-10), duration: 10),
task: task,
key: key,
abortFallback: now,
into: &transitions
)
- #expect(monitor.graph.completions.count == 1)
- #expect(monitor.graph.completions.first?.duration == nil)
+ #expect(graph.completions.count == 1)
+ #expect(graph.completions.first?.duration == nil)
#expect(transitions.isEmpty)
}
}
diff --git a/Tests/App/CodexStatus/AccountNotificationTests.swift b/Tests/App/CodexStatus/AccountNotificationTests.swift
index 8c8aa36..243f865 100644
--- a/Tests/App/CodexStatus/AccountNotificationTests.swift
+++ b/Tests/App/CodexStatus/AccountNotificationTests.swift
@@ -329,19 +329,24 @@ extension AccountNotificationTests {
try server.finish()
}
- @Test(arguments: ["serverError", "invalidPayload", "signedOut"])
- func failedAuthenticationRefreshCannotFallBackToSupplementalCache(failure: String) async throws {
+ @Test(arguments: [
+ ("serverError", true), ("invalidPayload", true), ("signedOut", true),
+ ("signedOut", false), ("authentication", false), ("serverError", false),
+ ("invalidPayload", false), ("connectionClosed", false)
+ ])
+ func authenticationRefreshFailurePreservesOutcomeAndRejectsCache(failure: String, hasCache: Bool) async throws {
let server = try SharedServerFixture { peer in
let initialize = try peer.readMessage()
try peer.reply(to: initialize, result: ["userAgent": "codex/0.162.0"])
_ = try peer.readMessage()
- for round in 0 ..< 2 {
+ let rounds = hasCache ? 2 : 1
+ for round in 0 ..< rounds {
let account = try peer.readMessage()
#expect(account["method"] as? String == "account/read")
try peer.reply(to: account, result: ["account": ["type": "apiKey"]])
let limits = try peer.readMessage()
#expect(limits["method"] as? String == "account/rateLimits/read")
- if round == 0 {
+ if round < rounds - 1 {
try peer.reply(to: limits, result: ["rateLimits": [:], "ordinaryUsageAllowed": true])
let usage = try peer.readMessage()
#expect(usage["method"] as? String == "account/usage/read")
@@ -355,8 +360,11 @@ extension AccountNotificationTests {
switch failure {
case "signedOut": try peer.reply(to: refresh, result: ["account": NSNull()])
case "invalidPayload": try peer.reply(to: refresh, result: [:])
+ case "connectionClosed": return
default:
- try peer.send(["id": #require(refresh["id"]), "error": ["code": -32000, "message": "upstream network request failed"]])
+ try peer.send(["id": #require(refresh["id"]), "error": [
+ "code": -32000, "message": failure == "authentication" ? "codex account authentication required" : "upstream network request failed"
+ ]])
}
}
}
@@ -364,17 +372,23 @@ extension AccountNotificationTests {
}
defer { server.close() }
let service = CodexStatusService(socketURL: server.url, logStorage: nil)
- guard case .data = await service.fetchOutcome().outcome else {
- Issue.record("Initial read did not populate the cache")
- return
+ if hasCache {
+ guard case .data = await service.fetchOutcome().outcome else {
+ Issue.record("Initial read did not populate the cache")
+ return
+ }
}
let result = await service.fetchOutcome()
#expect(result.trace.rateLimits == nil && result.trace.usage == nil)
#expect(result.trace.failureStage == .snapshot)
+ if !hasCache {
+ #expect(result.trace.connection == .new)
+ }
switch result.outcome {
case .notLoggedIn: #expect(failure == "signedOut")
- case .initializationFailed: #expect(failure != "signedOut")
- default: Issue.record("Authentication refresh failure was hidden by cached data")
+ case .authenticationRequired: #expect(failure == "authentication")
+ case .initializationFailed: #expect(["serverError", "invalidPayload", "connectionClosed"].contains(failure))
+ default: Issue.record("Authentication refresh failure was hidden or misclassified")
}
try server.finish()
}
@@ -473,44 +487,4 @@ extension AccountNotificationTests {
#expect(throws: DecodingError.self) { try TestFixtures.decode(AccountReadResponse.self, "{}") }
#expect(try TestFixtures.decode(AccountReadResponse.self, "{\"account\":null}").account == nil)
}
-
- @Test(arguments: ["signedOut", "authentication", "serverError", "invalidPayload", "connectionClosed"])
- func refreshFailureKeepsAuthenticationSeparateFromReadFailure(result: String) async throws {
- let server = try SharedServerFixture { peer in
- let initialize = try peer.readMessage()
- try peer.reply(to: initialize, result: ["userAgent": "codex/0.162.0"])
- _ = try peer.readMessage()
- let account = try peer.readMessage()
- try peer.reply(to: account, result: ["account": ["type": "apiKey"]])
- let limits = try peer.readMessage()
- #expect(limits["method"] as? String == "account/rateLimits/read")
- try peer.send(["id": #require(limits["id"]), "error": ["code": -32000, "message": "codex account authentication required"]])
- for _ in 0 ..< (result == "serverError" ? 2 : 1) {
- let refresh = try peer.readMessage()
- #expect(refresh["method"] as? String == "account/read")
- #expect((refresh["params"] as? [String: Any])?["refreshToken"] as? Bool == true)
- switch result {
- case "signedOut": try peer.reply(to: refresh, result: ["account": NSNull()])
- case "invalidPayload": try peer.reply(to: refresh, result: [:])
- case "connectionClosed": return
- default:
- try peer.send(["id": #require(refresh["id"]), "error": [
- "code": -32000, "message": result == "authentication" ? "codex account authentication required" : "upstream network request failed"
- ]])
- }
- }
- }
- defer { server.close() }
- let service = CodexStatusService(socketURL: server.url, logStorage: nil)
- let fetched = await service.fetchOutcome()
- #expect(fetched.trace.failureStage == .snapshot)
- #expect(fetched.trace.connection == .new)
- switch fetched.outcome {
- case .notLoggedIn: #expect(result == "signedOut")
- case .authenticationRequired: #expect(result == "authentication")
- case .initializationFailed: #expect(["serverError", "invalidPayload", "connectionClosed"].contains(result))
- default: Issue.record("Unexpected fetch outcome")
- }
- try server.finish()
- }
}
diff --git a/Tests/App/CodexStatus/CodexServiceStatusTests.swift b/Tests/App/CodexStatus/CodexServiceStatusTests.swift
index 1c52135..42ee5c0 100644
--- a/Tests/App/CodexStatus/CodexServiceStatusTests.swift
+++ b/Tests/App/CodexStatus/CodexServiceStatusTests.swift
@@ -97,67 +97,131 @@ struct CodexServiceStatusTests {
#expect(CodexServiceStatus.operational.componentNames.isEmpty)
}
- @Test func monitorCachesAcrossReopeningAndStopsWhileHidden() async throws {
+ @Test func disabledMonitorSkipsRefresh() async throws {
let probe = ServiceStatusProbe()
let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
- defer { monitor.setActive(false, refreshInterval: .seconds(60)) }
- monitor.setActive(false, refreshInterval: .seconds(60))
+ await monitor.refresh()
#expect(await probe.calls == 0)
- monitor.setActive(true, refreshInterval: .seconds(60))
- monitor.setActive(true, refreshInterval: .seconds(60))
- try await wait { monitor.state == .available(.operational) }
- monitor.setActive(false, refreshInterval: .seconds(60))
- monitor.setActive(true, refreshInterval: .seconds(60))
- try await Task.sleep(for: .milliseconds(30))
- #expect(await probe.calls == 1)
- monitor.setActive(false, refreshInterval: .milliseconds(10))
+ monitor.setEnabled(true)
+ await monitor.refresh()
+ #expect(monitor.state == .available(.operational))
+ monitor.setEnabled(false)
+ await monitor.refresh()
try await Task.sleep(for: .milliseconds(30))
#expect(await probe.calls == 1)
}
- @Test func changingIntervalReschedulesFromLastRefresh() async throws {
+ @Test func eachRefreshFetchesWithoutAnIndependentTimer() async throws {
let probe = ServiceStatusProbe()
let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
- defer { monitor.setActive(false, refreshInterval: .seconds(60)) }
- monitor.setActive(true, refreshInterval: .seconds(60))
- try await wait { monitor.state == .available(.operational) }
- monitor.setActive(true, refreshInterval: .milliseconds(10))
- try await wait { await probe.calls >= 2 }
- monitor.setActive(true, refreshInterval: .seconds(60))
- let count = await probe.calls
+ monitor.setEnabled(true)
+ await monitor.refresh()
+ await monitor.refresh()
+ #expect(await probe.calls == 2)
try await Task.sleep(for: .milliseconds(40))
- #expect(await probe.calls == count)
+ #expect(await probe.calls == 2)
+ }
+
+ @Test func concurrentRefreshesShareThePendingRequest() async throws {
+ let probe = ServiceStatusProbe(holdsFirst: true)
+ let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
+ defer { monitor.setEnabled(false) }
+ monitor.setEnabled(true)
+ let first = Task { await monitor.refresh() }
+ try await wait { await probe.calls == 1 }
+ let second = Task { await monitor.refresh() }
+ try await Task.sleep(for: .milliseconds(20))
+ #expect(await probe.calls == 1)
+ await probe.releaseFirst()
+ await first.value
+ await second.value
+ #expect(monitor.state == .available(.operational))
}
- @Test func failedRefreshDoesNotKeepShowingHealthy() async throws {
+ @Test func failedRefreshDoesNotKeepShowingHealthy() async {
let probe = ServiceStatusProbe()
let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
- defer { monitor.setActive(false, refreshInterval: .seconds(60)) }
- monitor.setActive(true, refreshInterval: .seconds(60))
- try await wait { monitor.state == .available(.operational) }
+ monitor.setEnabled(true)
+ await monitor.refresh()
+ #expect(monitor.state == .available(.operational))
await probe.fail()
- monitor.setActive(true, refreshInterval: .milliseconds(10))
- try await wait { monitor.state == .unavailable }
- monitor.setActive(false, refreshInterval: .seconds(60))
+ await monitor.refresh()
#expect(monitor.state == .unavailable)
+ await probe.recover()
+ await monitor.refresh()
+ #expect(monitor.state == .available(.operational))
}
- @Test func cancelledResultCannotOverwriteReopenedPanel() async throws {
+ @Test func cancelledResultCannotOverwriteReenabledMonitor() async throws {
let probe = ServiceStatusProbe(holdsFirst: true)
let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
- defer { monitor.setActive(false, refreshInterval: .seconds(60)) }
- monitor.setActive(true, refreshInterval: .seconds(60))
+ defer { monitor.setEnabled(false) }
+ monitor.setEnabled(true)
+ let first = Task { await monitor.refresh() }
try await wait { await probe.calls == 1 }
- monitor.setActive(false, refreshInterval: .seconds(60))
- monitor.setActive(true, refreshInterval: .seconds(60))
+ monitor.setEnabled(false)
+ monitor.setEnabled(true)
+ await monitor.refresh()
let outage = CodexServiceStatus(level: .fullOutage, componentNames: ["CLI"])
- try await wait { monitor.state == .available(outage) }
+ #expect(monitor.state == .available(outage))
await probe.releaseFirst()
- try await Task.sleep(for: .milliseconds(20))
+ await first.value
#expect(monitor.state == .available(outage))
#expect(await probe.calls == 2)
}
+ @Test(arguments: [LogTrigger.manual, .auto, .launch, .panelOpen, .settings])
+ func sharedUpdateTimeWaitsForServiceStatus(_ trigger: LogTrigger) async throws {
+ let preferences = try TestPreferences()
+ defer { preferences.remove() }
+ let probe = ServiceStatusProbe(holdsFirst: true)
+ let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
+ defer { monitor.setEnabled(false) }
+ monitor.setEnabled(true)
+ let model = CodexStatusViewModel(
+ service: CodexStatusService(socketURL: URL(fileURLWithPath: "/tmp/\(preferences.suite).sock"), logStorage: nil),
+ serviceStatusMonitor: monitor,
+ defaults: preferences.defaults
+ )
+ model.refresh(trigger: trigger)
+ try await wait { await probe.calls == 1 }
+ #expect(model.isRefreshing)
+ #expect(model.autoRefreshCountdownStartedAt == nil)
+ model.refresh(trigger: .manual)
+ await probe.releaseFirst()
+ try await wait { !model.isRefreshing }
+ #expect(monitor.state == .available(.operational))
+ #expect(model.autoRefreshCountdownStartedAt != nil)
+ #expect(await probe.calls == 1)
+ }
+
+ @Test func notificationsPreserveSharedTimeAndManualRefreshIncludesServiceFailure() async throws {
+ let preferences = try TestPreferences()
+ defer { preferences.remove() }
+ let probe = ServiceStatusProbe()
+ let monitor = CodexServiceStatusMonitor(fetch: { try await probe.fetch() })
+ monitor.setEnabled(true)
+ let model = CodexStatusViewModel(
+ service: CodexStatusService(socketURL: URL(fileURLWithPath: "/tmp/\(preferences.suite).sock"), logStorage: nil),
+ serviceStatusMonitor: monitor,
+ defaults: preferences.defaults
+ )
+ model.refresh(trigger: .manual)
+ try await wait { !model.isRefreshing }
+ let updatedAt = try #require(model.autoRefreshCountdownStartedAt)
+ await probe.fail()
+ model.refresh(trigger: .accountNotification)
+ try await wait { !model.isRefreshing }
+ #expect(model.autoRefreshCountdownStartedAt == updatedAt)
+ #expect(monitor.state == .available(.operational))
+ #expect(await probe.calls == 1)
+ model.refresh(trigger: .manual)
+ try await wait { !model.isRefreshing }
+ #expect(try #require(model.autoRefreshCountdownStartedAt) > updatedAt)
+ #expect(monitor.state == .unavailable)
+ #expect(await probe.calls == 2)
+ }
+
@Test(arguments: ["valid", "http-error", "invalid-json", "oversized-header", "oversized-body"])
func transportValidatesResponses(_ scenario: String) async throws {
let configuration = URLSessionConfiguration.ephemeral
@@ -228,6 +292,10 @@ private actor ServiceStatusProbe {
fails = true
}
+ func recover() {
+ fails = false
+ }
+
func releaseFirst() {
first?.resume(returning: .operational)
first = nil
diff --git a/Tests/App/History/HistoryDatabaseStoreTests.swift b/Tests/App/History/HistoryDatabaseStoreTests.swift
index d8d6261..763006f 100644
--- a/Tests/App/History/HistoryDatabaseStoreTests.swift
+++ b/Tests/App/History/HistoryDatabaseStoreTests.swift
@@ -198,7 +198,10 @@ struct HistoryDatabaseStoreTests {
let directory = try TestDirectory()
defer { try? directory.remove() }
let store = HistoryDatabaseStore.shared(in: directory.url)
- try await store.access { try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)") }
+ try await store.access {
+ try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)")
+ try $0.execute("PRAGMA busy_timeout = 0")
+ }
let external = try HistoryDatabase(directoryURL: directory.url)
try external.execute("BEGIN EXCLUSIVE")
do {
diff --git a/Tests/App/History/HistoryDatabaseTests.swift b/Tests/App/History/HistoryDatabaseTests.swift
index 3ed14a1..6f97941 100644
--- a/Tests/App/History/HistoryDatabaseTests.swift
+++ b/Tests/App/History/HistoryDatabaseTests.swift
@@ -404,17 +404,22 @@ extension HistoryDatabaseTests {
let now = Date()
let date = HistoryStorage.dateKey(for: now)
let store = TokenUsageHistoryStore(directoryURL: directory.url)
- _ = try await store.recordObservations([TestFixtures.tokenUsageObservation(at: now, tokenUsage: tokenUsage(20))], now: now)
+ let before = try await store.recordObservations([TestFixtures.tokenUsageObservation(at: now, tokenUsage: tokenUsage(20))], now: now)
try await store.appendObservation(TestFixtures.tokenUsageObservation(at: now, tokenUsage: tokenUsage(30)), now: now)
try database.append(event("activityData", at: now))
try database.execute("CREATE TRIGGER reject_tokenUsage BEFORE UPDATE OF tokenUsage ON aggregates BEGIN SELECT RAISE(ABORT, 'injected failure'); END")
- #expect(try await store.loadSnapshot(now: now).coverage == .partial)
+ let failed = try await store.loadSnapshot(now: now)
+ #expect(failed.coverage == .partial)
+ #expect(failed.aggregates == before)
#expect(try database.aggregateActivityData(date: date).eventCount == 1)
#expect(try database.tokenUsageAggregates().first?.tokenUsage == tokenUsage(20))
#expect(try database.pendingActivityDataDates().isEmpty)
#expect(try database.pendingTokenUsageDates() == [date])
try database.execute("DROP TRIGGER reject_tokenUsage")
- #expect(try await store.refresh(now: now).first?.tokenUsage == tokenUsage(50))
+ let recovered = try await store.loadSnapshot(now: now)
+ #expect(recovered.coverage == .complete)
+ #expect(recovered.aggregates.first?.tokenUsage == tokenUsage(50))
+ #expect(try await store.refresh(now: now) == recovered.aggregates)
#expect(try database.activityDataAggregates().first?.eventCount == 1)
}
@@ -524,25 +529,6 @@ extension HistoryDatabaseTests {
#expect(rebuilt.failedDateKeys == [HistoryStorage.dateKey(for: yesterday)])
}
- @Test func failedDailyCommitKeepsCursorAndRetryCountsIncrementOnce() async throws {
- let directory = try TestDirectory()
- defer { try? directory.remove() }
- let now = Date()
- let store = TokenUsageHistoryStore(directoryURL: directory.url)
- let before = try await store.recordObservations([TestFixtures.tokenUsageObservation(at: now, tokenUsage: tokenUsage(10))], now: now)
- try await store.appendObservation(TestFixtures.tokenUsageObservation(at: now, tokenUsage: tokenUsage(20)), now: now)
- let database = try HistoryDatabase(directoryURL: directory.url)
- try database.execute("CREATE TRIGGER reject_tokenUsage BEFORE UPDATE OF tokenUsage ON aggregates BEGIN SELECT RAISE(ABORT, 'injected failure'); END")
- let failed = try await store.loadSnapshot(now: now)
- #expect(failed.coverage == .partial)
- #expect(failed.aggregates == before)
- try database.execute("DROP TRIGGER reject_tokenUsage")
- let recovered = try await store.loadSnapshot(now: now)
- #expect(recovered.coverage == .complete)
- #expect(recovered.aggregates.first?.tokenUsage == tokenUsage(30))
- #expect(try await store.refresh(now: now) == recovered.aggregates)
- }
-
@Test func missingObservationCannotReplaceSavedDailyTotalDuringRebuild() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
diff --git a/Tests/App/Presentation/ActivityCardLayoutTests.swift b/Tests/App/Presentation/ActivityCardLayoutTests.swift
deleted file mode 100644
index 6fc3246..0000000
--- a/Tests/App/Presentation/ActivityCardLayoutTests.swift
+++ /dev/null
@@ -1,491 +0,0 @@
-import AppKit
-import SwiftUI
-import Testing
-
-@Suite(.serialized)
-struct ActivityCardLayoutTests {
- @Test func hidingKeepsOriginalTaskSymbolVisible() async throws {
- let fixture = try CardFixture(hasTokens: true, anchorEdge: .minY)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- #expect(try fixture.bluePixelCount() > 12)
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- try await Task.sleep(for: .milliseconds(40))
- #expect(try fixture.bluePixelCount() > 12, "The departing task changed to the gray idle placeholder")
- }
-
- @Test(arguments: [false, true])
- func hidingSectionStartsGently(hasTokens: Bool) async throws {
- let fixture = try CardFixture(hasTokens: hasTokens, anchorEdge: .minY)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let visible = fixture.height
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- try await Task.sleep(for: .milliseconds(60))
- let firstMovement = visible - fixture.height
- let totalMovement: CGFloat = (hasTokens ? 108 : 58) + 10
- #expect(firstMovement < totalMovement * 0.4, "The drawer collapsed too abruptly at the start: \(firstMovement) / \(totalMovement)")
- }
-
- @Test func resizingPopoverKeepsHeaderAtSameScreenPosition() async throws {
- let fixture = try CardFixture(hasTokens: false, anchorEdge: .minY, panelWidth: 491)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let initial = try #require(fixture.headerFrame.currentScreenFrame()).maxY
- var offsets: [CGFloat] = []
- for hasTokens: Bool? in [true, false, nil, false, true, nil] {
- if let hasTokens {
- fixture.update(hasTokens: hasTokens, newTask: true)
- } else {
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- }
- for _ in 0 ..< 45 {
- try await Task.sleep(for: .milliseconds(16))
- let header = try #require(fixture.headerFrame.currentScreenFrame())
- offsets.append(header.maxY - initial)
- }
- }
- #expect(offsets.allSatisfy { abs($0) < 0.1 }, "Stationary header moved during resizing: \(offsets)")
- }
-
- @Test func restoringSectionKeepsCardAboveHistory() async throws {
- let fixture = try CardFixture(hasTokens: false, anchorEdge: .minY)
- defer { fixture.close() }
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- _ = try await fixture.sampleHeights()
- fixture.update(hasTokens: false, newTask: true)
- var gaps: [CGFloat] = []
- for _ in 0 ..< 45 {
- try await Task.sleep(for: .milliseconds(16))
- if let card = fixture.cardFrame.currentScreenFrame(), let history = fixture.historyFrame.currentScreenFrame() {
- gaps.append(card.minY - history.maxY)
- }
- }
- #expect(gaps.count > 3)
- #expect(gaps.allSatisfy { $0 >= 9.5 }, "The revealing card overlapped the history section: \(gaps)")
- }
-
- @Test(arguments: [false, true])
- func taskTokenHeightChangesContinuously(collapsing: Bool) async throws {
- let fixture = try CardFixture(hasTokens: collapsing, animationSpeed: 0.25)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let initial = fixture.height
- fixture.update(hasTokens: !collapsing)
- let heights = try await fixture.sampleHeights()
- let final = try #require(heights.last)
- #expect(abs(final - initial) >= 49)
- expectContinuous(heights, from: initial, to: final)
- }
-
- @Test func switchingTasksAndReversingDuringExpansionStaysWithinBounds() async throws {
- let fixture = try CardFixture(hasTokens: false)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let initial = fixture.height
- fixture.update(hasTokens: true, newTask: true)
- let expanding = try await fixture.sampleHeights(count: 10)
- let turningPoint = fixture.height
- #expect(turningPoint > initial + 1)
- fixture.update(hasTokens: false, newTask: true)
- let collapsing = try await fixture.sampleHeights()
- #expect(abs(fixture.height - initial) < 1)
- #expect((expanding + collapsing).allSatisfy { $0 >= initial - 1 && $0 <= initial + 51 })
- #expect(collapsing.contains { $0 > initial + 1 && $0 < turningPoint - 1 })
- // 反向时保留短暂的连续速度, 随后必须稳定收回且不能越过目标范围
- #expect((collapsing.max() ?? turningPoint) <= turningPoint + 10)
- let settledDirection = Array(collapsing.dropFirst(7))
- #expect(zip(settledDirection, settledDirection.dropFirst()).allSatisfy { $1 <= $0 + 1 }, "Reversal continued expanding: \(collapsing)")
- }
-
- @Test func disabledAnimationsApplyFinalHeightImmediately() async throws {
- let fixture = try CardFixture(hasTokens: false, allowsAnimations: false)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let initial = fixture.height
- fixture.update(hasTokens: true)
- let heights = try await fixture.sampleHeights(count: 6)
- #expect(abs(fixture.height - initial - 50) < 1)
- #expect(heights.allSatisfy { abs($0 - initial) < 1 || abs($0 - initial - 50) < 1 })
- }
-
- @Test(arguments: [0.25, 0.75, 0.999, 1.0])
- func sectionRevealPreservesShadowOutsideVisibleCard(progress: CGFloat) throws {
- let fixture = try CardFixture(hasTokens: true)
- defer { fixture.close() }
- let card = ActivityCard(
- activityMonitor: fixture.monitor,
- presentationState: ActivityCenterPresentationState(),
- keepAliveController: KeepAliveController(activityMonitor: fixture.monitor, defaults: fixture.preferences.defaults),
- onTaskCenterTap: { _ in }
- )
- .modifier(ActivitySectionReveal(height: 108 * progress, progress: progress))
- .frame(width: 300)
- .padding(40)
- .environment(\.colorScheme, .light)
- let renderer = ImageRenderer(content: card)
- renderer.scale = 2
- let bitmap = try NSBitmapImageRep(cgImage: #require(renderer.cgImage))
- let shadow = try #require(bitmap.colorAt(x: bitmap.pixelsWide / 2, y: bitmap.pixelsHigh - 72))
- #expect(shadow.alphaComponent > 0, "The drawer clipped its shadow at the visible bottom edge")
- }
-
- @Test func switchingToWrappedHeaderAndBackAnimatesNaturalHeight() async throws {
- let fixture = try CardFixture(hasTokens: true, animationSpeed: 0.25)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let initial = fixture.height
- fixture.update(hasTokens: true, newTask: true)
- fixture.monitor.graph.tasks[fixture.key]?.projectName = String(repeating: "Long project name ", count: 5)
- fixture.monitor.refreshSnapshot(now: fixture.now)
- let expanding = try await fixture.sampleHeights()
- let expanded = fixture.height
- #expect(expanded > initial + 1)
- expectContinuous(expanding, from: initial, to: expanded)
- fixture.update(hasTokens: true, newTask: true)
- let collapsing = try await fixture.sampleHeights()
- #expect(abs(fixture.height - initial) < 1)
- expectContinuous(collapsing, from: expanded, to: initial)
- }
-
- @Test(arguments: [false, true], [480, 560])
- func wrappedHeaderKeepsSymbolAndFirstLineAtSameHeight(hasTokens: Bool, width: Int) throws {
- let fixture = try CardFixture(hasTokens: hasTokens, allowsAnimations: false)
- defer { fixture.close() }
- let initial = try fixture.renderedHeaderPosition(width: CGFloat(width))
- for wraps in [true, false] {
- fixture.update(hasTokens: hasTokens, newTask: true)
- fixture.monitor.graph.tasks[fixture.key]?.projectName = wraps
- ? "CodexBar " + String(repeating: "long project name ", count: 5)
- : "CodexBar"
- fixture.monitor.refreshSnapshot(now: fixture.now)
- let updated = try fixture.renderedHeaderPosition(width: CGFloat(width))
- #expect(wraps ? updated.height > initial.height : updated.height == initial.height)
- #expect(updated.symbolTop == initial.symbolTop, "The task symbol moved when the header wrapping changed")
- #expect(updated.firstLineTop == initial.firstLineTop, "The first header line moved when the header wrapping changed")
- }
- }
-
- @Test func hidingAndRestoringSectionAnimatesHostHeight() async throws {
- let fixture = try CardFixture(hasTokens: false)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let visible = fixture.height
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- let collapsing = try await fixture.sampleHeights()
- let hidden = fixture.height
- #expect(abs(visible - hidden - 68) < 1)
- expectContinuous(collapsing, from: visible, to: hidden)
- fixture.update(hasTokens: false, newTask: true)
- let expanding = try await fixture.sampleHeights()
- #expect(abs(fixture.height - visible) < 1)
- expectContinuous(expanding, from: hidden, to: visible)
- }
-
- @Test(arguments: [false, true], ActivityPlacement.allCases)
- func hidingSectionDoesNotSnapAtEnd(hasTokens: Bool, placement: ActivityPlacement) async throws {
- let fixture = try CardFixture(hasTokens: hasTokens, anchorEdge: .minY, placement: placement)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let visible = fixture.height
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- let heights = try await fixture.sampleHeights()
- let steps = zip(heights, heights.dropFirst()).map { abs($1 - $0) }.filter { $0 > 0 }
- let finalStep = try #require(steps.last)
- #expect(finalStep <= 2, "The drawer snapped on its final moving frame: \(heights)")
- let removedHeight: CGFloat = (hasTokens ? 108 : 58) + (placement == .only ? 0 : 10)
- #expect(abs(visible - fixture.height - removedHeight) < 1)
- }
-
- @Test func reversingSectionRemovalKeepsTheRestoredCard() async throws {
- let fixture = try CardFixture(hasTokens: false)
- defer { fixture.close() }
- try await Task.sleep(for: .milliseconds(100))
- let visible = fixture.height
- for _ in 0 ..< 3 {
- fixture.monitor.graph.tasks.removeAll()
- fixture.monitor.refreshSnapshot(now: fixture.now)
- _ = try await fixture.sampleHeights(count: 8)
- #expect(fixture.height < visible - 1)
- fixture.update(hasTokens: false, newTask: true)
- _ = try await fixture.sampleHeights(count: 8)
- }
- _ = try await fixture.sampleHeights()
- #expect(abs(fixture.height - visible) < 1)
- }
-
- private func expectContinuous(_ heights: [CGFloat], from initial: CGFloat, to final: CGFloat) {
- let lower = min(initial, final)
- let upper = max(initial, final)
- #expect(
- heights.filter { $0 > lower + 1 && $0 < upper - 1 }.count >= 3,
- "Host height jumped instead of revealing the drawer: \(heights)"
- )
- #expect(heights.allSatisfy { $0 >= lower - 1 && $0 <= upper + 1 })
- let changes = zip([initial] + heights, heights).map { $1 - $0 }
- #expect(changes.allSatisfy { abs($0) < (upper - lower) * 0.7 })
- #expect(changes.allSatisfy { final > initial ? $0 >= -1 : $0 <= 1 })
- }
-
- @Test func narrowStatusContentExpandsWithoutClipping() {
- let short = statusSize(width: 300, long: false)
- let wide = statusSize(width: 480, long: true)
- let narrow = statusSize(width: 180, long: true)
- #expect(narrow.width == 180)
- #expect(narrow.height > wide.height)
- #expect(narrow.height > short.height)
- #expect(narrow.height.isFinite)
- }
-
- @Test func wrappedSupplementUsesOneLineEvenWhenItIsVeryLong() {
- let short = supplementarySize("2 个子 Agent 运行中")
- let long = supplementarySize(String(repeating: "附加信息", count: 40))
- #expect(long.width == 140)
- #expect(long.height == short.height)
- }
-
- private func supplementarySize(_ supplement: String) -> CGSize {
- let content = ActivityStatusText(
- text: "正在读取文件, 浏览目录, 搜索文件内容",
- tint: .blue, effect: .none, lineLimit: nil, supplement: supplement
- )
- .fixedSize(horizontal: false, vertical: true)
- .frame(width: 140, alignment: .leading)
- return NSHostingView(rootView: content).fittingSize
- }
-
- private func statusSize(width: CGFloat, long: Bool) -> CGSize {
- let content = VStack(alignment: .leading, spacing: 3) {
- Text("CodexBar • gpt-6-astra • high • 已运行 1 小时 24 分")
- .font(.caption.weight(.semibold))
- .fixedSize(horizontal: false, vertical: true)
- ActivityStatusText(
- text: long ? "正在读取文件, 浏览目录, 搜索文件内容" : "正在回答",
- tint: .blue, effect: .none, lineLimit: nil, supplement: "3 个子 Agent 运行中"
- )
- .fixedSize(horizontal: false, vertical: true)
- Text("最近事件: 读取文件, 浏览目录, 搜索内容完成")
- .font(.caption2)
- .fixedSize(horizontal: false, vertical: true)
- }
- .frame(width: width, alignment: .leading)
- return NSHostingView(rootView: content).fittingSize
- }
-}
-
-enum ActivityPlacement: CaseIterable {
- case first, middle, last, only
-}
-
-private final class CardFixture {
- struct HeaderPosition {
- let height: Int
- let symbolTop: Int
- let firstLineTop: Int
- }
-
- let directory: TestDirectory
- let preferences: TestPreferences
- let monitor: ActivityMonitor
- let controller: NSHostingController<AnyView>
- let window: NSWindow
- let popover: NSPopover
- let now = Date()
- let key = ActivityTaskKey(thread: "drawer", turn: "turn")
- let headerFrame = ScreenFrameProvider()
- let cardFrame = ScreenFrameProvider()
- let historyFrame = ScreenFrameProvider()
- let animationSpeed: Double
-
- var height: CGFloat {
- controller.preferredContentSize.height
- }
-
- init(
- hasTokens: Bool,
- allowsAnimations: Bool = true,
- animationSpeed: Double = 1,
- anchorEdge: NSRectEdge = .maxX,
- panelWidth: CGFloat = 560,
- placement: ActivityPlacement = .middle
- ) throws {
- self.animationSpeed = animationSpeed
- directory = try TestDirectory()
- preferences = try TestPreferences()
- monitor = ActivityMonitor(
- protectionSettings: ProtectionSettings(defaults: preferences.defaults),
- protectionStore: ProtectionStore(directoryURL: directory.url),
- activityDataDirectoryURL: directory.url
- )
- var task = ActivityTask(
- displayID: UUID(), key: key,
- event: TestFixtures.event(at: now, thread: key.threadID, turn: key.turnID),
- state: .running, startedAt: now, progressGeneration: 1
- )
- task.projectName = "CodexBar"
- task.tokenUsage = hasTokens ? .zero : nil
- monitor.graph.tasks[key] = task
- monitor.isActivitySourceHealthy = true
- monitor.refreshSnapshot(now: now)
- let content = CardFixturePanel(
- monitor: monitor,
- keepAlive: KeepAliveController(activityMonitor: monitor, defaults: preferences.defaults),
- headerFrame: headerFrame,
- cardFrame: cardFrame,
- historyFrame: historyFrame,
- placement: placement
- )
- .padding(12)
- .frame(width: panelWidth)
- .fixedSize(horizontal: false, vertical: true)
- let root = MenuPanelLayout { content }
- .environment(\.mainPanelAnimationsEnabled, allowsAnimations)
- // 连续性测试放慢动画, 避免一次调度延迟跨过大部分中间帧
- .transaction { transaction in
- transaction.animation = transaction.animation?.speed(animationSpeed)
- }
- controller = NSHostingController(rootView: AnyView(root))
- controller.sizingOptions = [.preferredContentSize]
- let screen = NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 1440, height: 900)
- let anchorY = anchorEdge == .minY ? screen.maxY - 64 : 400
- window = NSWindow(contentRect: NSRect(x: 100, y: anchorY, width: 40, height: 40), styleMask: [.borderless], backing: .buffered, defer: false)
- window.isReleasedWhenClosed = false
- window.contentView = NSView(frame: NSRect(x: 0, y: 0, width: 40, height: 40))
- window.orderFront(nil)
- popover = NSPopover()
- popover.animates = false
- popover.contentViewController = controller
- let anchor = try #require(window.contentView)
- popover.show(relativeTo: anchor.bounds, of: anchor, preferredEdge: anchorEdge)
- }
-
- func update(hasTokens: Bool, newTask: Bool = false) {
- if newTask {
- var task = ActivityTask(
- displayID: UUID(), key: key,
- event: TestFixtures.event(at: now, thread: key.threadID, turn: key.turnID),
- state: .running, startedAt: now, progressGeneration: 1
- )
- task.projectName = hasTokens ? "Peekaboo" : "CodexBar"
- monitor.graph.tasks[key] = task
- }
- monitor.graph.tasks[key]?.tokenUsage = hasTokens ? .zero : nil
- monitor.refreshSnapshot(now: now)
- }
-
- func sampleHeights(count: Int = 45) async throws -> [CGFloat] {
- var heights: [CGFloat] = []
- // 保持采样间隔, 按动画速度同步延长观察窗口
- let sampleCount = Int((Double(count) / animationSpeed).rounded(.up))
- for _ in 0 ..< sampleCount {
- try await Task.sleep(for: .milliseconds(16), tolerance: .zero)
- heights.append(height)
- #expect(abs(popover.contentSize.height - height) < 1)
- }
- return heights
- }
-
- func bluePixelCount() throws -> Int {
- let view = controller.view
- let bitmap = try #require(view.bitmapImageRepForCachingDisplay(in: view.bounds))
- view.cacheDisplay(in: view.bounds, to: bitmap)
- var count = 0
- for y in stride(from: 0, to: bitmap.pixelsHigh, by: 2) {
- for x in stride(from: 0, to: bitmap.pixelsWide, by: 2) {
- guard let color = bitmap.colorAt(x: x, y: y)?.usingColorSpace(.sRGB) else { continue }
- if color.blueComponent > color.redComponent + 0.2,
- color.blueComponent > color.greenComponent + 0.05 {
- count += 1
- }
- }
- }
- return count
- }
-
- func renderedHeaderPosition(width: CGFloat) throws -> HeaderPosition {
- let card = ActivityCard(
- activityMonitor: monitor,
- presentationState: ActivityCenterPresentationState(),
- keepAliveController: KeepAliveController(activityMonitor: monitor, defaults: preferences.defaults),
- onTaskCenterTap: { _ in }
- )
- .frame(width: width)
- .fixedSize(horizontal: false, vertical: true)
- .background(.white)
- .environment(\.mainPanelAnimationsEnabled, false)
- .environment(\.colorScheme, .light)
- let renderer = ImageRenderer(content: card)
- renderer.scale = 2
- let bitmap = try NSBitmapImageRep(cgImage: #require(renderer.cgImage))
- var symbolTop: Int?
- var firstLineTop: Int?
- // 分别扫描图标和标题开头, 避开下面的状态文字和 Token 区域
- for y in 0 ..< min(64, bitmap.pixelsHigh) {
- for x in 24 ..< 180 {
- guard let color = bitmap.colorAt(x: x, y: y)?.usingColorSpace(.sRGB) else { continue }
- if x < 64, color.blueComponent > color.redComponent + 0.2,
- color.blueComponent > color.greenComponent + 0.05 {
- symbolTop = symbolTop ?? y
- }
- if x >= 84, max(color.redComponent, color.greenComponent, color.blueComponent) < 0.4 {
- firstLineTop = firstLineTop ?? y
- }
- }
- }
- return try HeaderPosition(height: bitmap.pixelsHigh, symbolTop: #require(symbolTop), firstLineTop: #require(firstLineTop))
- }
-
- func close() {
- popover.close()
- window.close()
- preferences.remove()
- try? directory.remove()
- }
-}
-
-private struct CardFixturePanel: View {
- @ObservedObject var monitor: ActivityMonitor
- let keepAlive: KeepAliveController
- let headerFrame: ScreenFrameProvider
- let cardFrame: ScreenFrameProvider
- let historyFrame: ScreenFrameProvider
- let placement: ActivityPlacement
-
- var body: some View {
- MenuSectionLayout(spacing: 10) {
- if placement == .first || placement == .only {
- activity
- }
- if placement != .only {
- Text("Quota").frame(maxWidth: .infinity).frame(height: 50).background(.gray.opacity(0.2))
- .background { ScreenFrameReader(provider: headerFrame) }
- if placement == .middle {
- activity
- }
- Text("History").frame(maxWidth: .infinity).frame(height: 100).background(.green.opacity(0.2))
- .background { ScreenFrameReader(provider: historyFrame) }
- }
- if placement == .last {
- activity
- }
- }
- }
-
- private var activity: some View {
- ActivitySection(isVisible: monitor.snapshot.hasTaskCenterContent) {
- ActivityCard(
- activityMonitor: monitor,
- presentationState: ActivityCenterPresentationState(),
- keepAliveController: keepAlive,
- onTaskCenterTap: { _ in }
- )
- .background { ScreenFrameReader(provider: cardFrame) }
- }
- }
-}
diff --git a/Tests/App/Support/TestSupport.swift b/Tests/App/Support/TestSupport.swift
index b1eb6f0..72e0fdd 100644
--- a/Tests/App/Support/TestSupport.swift
+++ b/Tests/App/Support/TestSupport.swift
@@ -38,6 +38,12 @@ nonisolated enum TestFixtures {
TokenUsageObservation(id: id, observedAt: date, previous: previous, current: TokenUsageUpdate(total: previous.adding(tokenUsage)!, last: tokenUsage))
}
+ static func activityDataAggregate(date: String, events: Int = 1) -> ActivityDataAggregate {
+ var aggregate = ActivityDataAggregate(date: date)
+ aggregate.eventCount = events
+ return aggregate
+ }
+
static func aggregate(
events: Int = 2,
turns: Int = 1
@@ -71,7 +77,7 @@ nonisolated struct TestDirectory {
try write(Data(text.utf8), to: relativePath)
}
- func seedTokenUsageAggregates(_ aggregates: [TokenUsageAggregate], now _: Date) async throws {
+ func seedTokenUsageAggregates(_ aggregates: [TokenUsageAggregate]) throws {
let database = try HistoryDatabase(directoryURL: url)
for var aggregate in aggregates {
aggregate.position = 0
@@ -131,14 +137,6 @@ struct TestPreferences {
}
}
-nonisolated extension TestDirectory {
- func activityDataAggregate(date: String, events: Int = 1) throws -> ActivityDataAggregate {
- var aggregate = ActivityDataAggregate(date: date)
- aggregate.eventCount = events
- return aggregate
- }
-}
-
nonisolated extension HistoryDatabase {
func exportJSONLines(date: String) throws -> Data {
var result = Data()
diff --git a/Tests/App/Sync/SyncRecoveryTests.swift b/Tests/App/Sync/SyncRecoveryTests.swift
index bb55b2f..3878a48 100644
--- a/Tests/App/Sync/SyncRecoveryTests.swift
+++ b/Tests/App/Sync/SyncRecoveryTests.swift
@@ -37,7 +37,7 @@ struct SyncRecoveryTests {
defer { try? directory.remove() }
let database = SyncDatabaseFixture()
let date = HistoryStorage.dateKey(for: Date())
- let local = try directory.activityDataAggregate(date: date)
+ let local = TestFixtures.activityDataAggregate(date: date)
let service = SyncService(database: database, directoryURL: directory.url, isEnabled: { true })
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [local], trigger: .manual)
#expect(await service.hasPendingActivityDataUpdates(local: [local]) == false)
@@ -67,7 +67,6 @@ struct SyncRecoveryTests {
}
private static let zone = CKRecordZone.ID(zoneName: SyncCloudKit.zoneName, ownerName: CKCurrentUserDefaultName)
- private static let salt = Data(repeating: 1, count: 32)
@Test func damagedActivityDataCursorRebuildsWithoutBlockingTokenUsage() async throws {
let directory = try TestDirectory()
@@ -106,7 +105,7 @@ struct SyncRecoveryTests {
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [], trigger: .manual)
let store = ActivityDataSyncStore(directoryURL: directory.url)
let date = HistoryStorage.dateKey(for: Date())
- let daily = try directory.activityDataAggregate(date: date).syncedAggregate
+ let daily = TestFixtures.activityDataAggregate(date: date).syncedAggregate
let stale = try ActivityDataSyncRecord(deviceID: "stale", activityData: daily, recordName: "activityData_stale_\(date)")
try store.saveFetchedRecords([stale.id: stale], cursor: nil)
let url = directory.url.appendingPathComponent("activityData/cache.json")
@@ -117,7 +116,7 @@ struct SyncRecoveryTests {
let deleted = CKRecord(recordType: "ActivityData", recordID: CKRecord.ID(recordName: "activityData_deleted_\(date)", zoneID: Self.zone))
try ActivityDataRecordCodec.apply(daily, deviceID: "deleted", to: deleted)
let expiredDate = HistoryStorage.dateKey(for: HistoryStorage.retentionCutoffDate().addingTimeInterval(-86400))
- let expiredDaily = try directory.activityDataAggregate(date: expiredDate).syncedAggregate
+ let expiredDaily = TestFixtures.activityDataAggregate(date: expiredDate).syncedAggregate
let expired = CKRecord(recordType: "ActivityData", recordID: CKRecord.ID(recordName: "activityData_remote_\(expiredDate)", zoneID: Self.zone))
try ActivityDataRecordCodec.apply(expiredDaily, deviceID: "remote", to: expired)
let metadata = CKRecord(recordType: "Metadata", recordID: CKRecord.ID(recordName: "ignored", zoneID: Self.zone))
@@ -211,7 +210,7 @@ struct SyncRecoveryTests {
let directory = try TestDirectory()
defer { try? directory.remove() }
let dates = (0 ..< 30).map { HistoryStorage.dateKey(for: Date().addingTimeInterval(Double(-$0) * 86400)) }
- let aggregates = try dates.map { try directory.activityDataAggregate(date: $0) }
+ let aggregates = dates.map { TestFixtures.activityDataAggregate(date: $0) }
let database = SyncDatabaseFixture(failingDate: dates[0], uploadFailure: code)
let service = SyncService(
database: database,
@@ -239,7 +238,7 @@ struct SyncRecoveryTests {
.success(SyncChanges(records: [:], deletions: [], token: nil, moreComing: false)),
.failure(CKError(.networkFailure))
])
- let local = try directory.activityDataAggregate(date: HistoryStorage.dateKey(for: Date()))
+ let local = TestFixtures.activityDataAggregate(date: HistoryStorage.dateKey(for: Date()))
let service = SyncService(database: database, directoryURL: directory.url, isEnabled: { true })
let snapshot = await service.synchronizeIfEnabled(localActivityDataAggregates: [local], trigger: .manual)
#expect(!snapshot.isActivityDataComplete)
@@ -426,7 +425,7 @@ struct SyncRecoveryTests {
directoryURL: directory.url,
isEnabled: { true }
)
- var local = try directory.activityDataAggregate(date: HistoryStorage.dateKey(for: Date()))
+ var local = TestFixtures.activityDataAggregate(date: HistoryStorage.dateKey(for: Date()))
local.eventCount = 1
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [local], trigger: .manual)
#expect(await database.activityDataRecords().isEmpty)
@@ -518,7 +517,6 @@ private actor SyncDatabaseFixture: SyncDatabase {
private(set) var deletedIDs: [CKRecord.ID] = []
private var changesRecord: CKRecord?
private var deletionFails = false
- private var activityDataSaveCallback: (@Sendable () -> Void)?
var remainingChangesPages: Int {
changesPages.count
@@ -536,10 +534,6 @@ private actor SyncDatabaseFixture: SyncDatabase {
failingDate = date
}
- func afterActivityDataSave(_ callback: @escaping @Sendable () -> Void) {
- activityDataSaveCallback = callback
- }
-
func activityDataRecords() -> [CKRecord] {
stored.values.filter { $0.recordType == "ActivityData" }.map(Self.copy)
}
@@ -576,7 +570,6 @@ private actor SyncDatabaseFixture: SyncDatabase {
func repair() {
failingName = nil
failingDate = nil
- activityDataSaveCallback = nil
}
func records(for ids: [CKRecord.ID], desiredKeys _: [CKRecord.FieldKey]?) async throws -> Records {
@@ -603,9 +596,6 @@ private actor SyncDatabaseFixture: SyncDatabase {
stored[record.recordID] = record.copy() as? CKRecord
saved[record.recordID] = .success(record)
savedTypes.append(record.recordType)
- if record.recordType == "ActivityData" {
- activityDataSaveCallback?()
- }
}
}
deletedIDs.append(contentsOf: ids)
@@ -1040,7 +1030,7 @@ extension SyncRecoveryTests {
let store = TokenUsageHistoryStore(directoryURL: directory.url)
var old = try #require(try await store.recordObservations([observation], now: now).first)
old.tokenUsage = Self.counts(120)
- try await directory.seedTokenUsageAggregates([old], now: now)
+ try directory.seedTokenUsageAggregates([old])
let database = SyncDatabaseFixture()
let sync = TokenUsageSync(database: database, directoryURL: directory.url.appendingPathComponent("Sync/tokenUsage"), isEnabled: { true })
try await sync.synchronize(local: [old], accountScopedDeviceID: "device", zoneID: Self.zone)
@@ -1109,7 +1099,7 @@ extension SyncRecoveryTests {
defer { try? directory.remove() }
let database = SyncDatabaseFixture()
let date = HistoryStorage.dateKey(for: Date())
- let local = try directory.activityDataAggregate(date: date)
+ let local = TestFixtures.activityDataAggregate(date: date)
let service = SyncService(database: database, directoryURL: directory.url, isEnabled: { true })
_ = await service.synchronizeIfEnabled(localActivityDataAggregates: [local], localTokenUsageAggregates: [Self.turn(0)], trigger: .manual)
diff --git a/Tests/App/Sync/ZoneRecoveryTests.swift b/Tests/App/Sync/ZoneRecoveryTests.swift
index 0eba1bb..ef7ced8 100644
--- a/Tests/App/Sync/ZoneRecoveryTests.swift
+++ b/Tests/App/Sync/ZoneRecoveryTests.swift
@@ -15,8 +15,8 @@ struct ZoneRecoveryTests {
_ = try directory.write("invalid activityData cache", to: "activityData/cache.json")
_ = try directory.write("invalid token cache", to: "tokenUsage/cache.json")
let service = service(database, directory)
- let snapshot = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory)],
+ let snapshot = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(snapshot.currentDeviceID != nil)
@@ -32,8 +32,8 @@ struct ZoneRecoveryTests {
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
- _ = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory), aggregate(1, directory: directory)],
+ _ = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
@@ -46,8 +46,8 @@ struct ZoneRecoveryTests {
}
// 保留 salt 可以验证恢复不依赖设备 ID 碰巧变化
await database.failOnce(at: point, wrapped: wrapped, preservingSalt: true)
- let snapshot = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, events: 3, directory: directory)],
+ let snapshot = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0, events: 3)],
localTokenUsageAggregates: [turn(0, tokens: 3)],
trigger: .manual
)
@@ -65,14 +65,14 @@ struct ZoneRecoveryTests {
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
- let first = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory), aggregate(1, directory: directory)],
+ let first = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
await database.recreateByPeer()
- let second = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory)],
+ let second = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(first.currentDeviceID != second.currentDeviceID)
@@ -90,8 +90,8 @@ struct ZoneRecoveryTests {
defer { try? directory.remove() }
let database = ZoneDatabase()
let first = service(database, directory)
- _ = try await first.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory), aggregate(1, directory: directory)],
+ _ = await first.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0), aggregate(1)],
localTokenUsageAggregates: [turn(0), turn(1)],
trigger: .manual
)
@@ -108,7 +108,7 @@ struct ZoneRecoveryTests {
#expect(snapshot.activityData.isEmpty)
#expect(snapshot.tokenUsageByDate?.isEmpty == true)
#expect(try store.load().records.isEmpty)
- let synced = try await next.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0, directory: directory)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
+ let synced = await next.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(synced.currentDeviceID != nil)
#expect(synced.activityData.count == 1)
#expect(try cachedTokenUsageCount(directory) == 1)
@@ -123,8 +123,8 @@ struct ZoneRecoveryTests {
let database = ZoneDatabase()
await database.failOnce(at: .query, repeats: true)
let service = service(database, directory)
- let failed = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory)],
+ let failed = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(await database.queryCount == 2)
@@ -132,8 +132,8 @@ struct ZoneRecoveryTests {
#expect(failed.currentDeviceID == nil)
#expect(try ActivityDataSyncStore(directoryURL: directory.url).load().records.isEmpty)
await database.repair()
- let recovered = try await service.synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory)],
+ let recovered = await service.synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)], trigger: .manual
)
#expect(recovered.currentDeviceID != nil)
@@ -148,11 +148,11 @@ struct ZoneRecoveryTests {
defer { try? directory.remove() }
let database = ZoneDatabase()
let service = service(database, directory)
- _ = try await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0, directory: directory)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
+ _ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
let before = ActivityDataSyncStore(directoryURL: directory.url).loadState()
let tokens = try Data(contentsOf: directory.url.appendingPathComponent("tokenUsage/cache.json"))
await database.rejectChanges(code)
- _ = try await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0, directory: directory)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
+ _ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(await database.creations == 0)
#expect(ActivityDataSyncStore(directoryURL: directory.url).loadState() == before)
#expect(try Data(contentsOf: directory.url.appendingPathComponent("tokenUsage/cache.json")) == tokens)
@@ -169,7 +169,7 @@ struct ZoneRecoveryTests {
directoryURL: directory.url,
isEnabled: { enabled.withLock { $0 } }
)
- _ = try await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0, directory: directory)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
+ _ = await service.synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], localTokenUsageAggregates: [turn(0)], trigger: .manual)
#expect(await database.creations == 0)
#expect(await database.recordCount("Metadata") == 0)
}
@@ -181,18 +181,18 @@ struct ZoneRecoveryTests {
await database.removeZone()
let store = ActivityDataSyncStore(directoryURL: directory.url)
try store.saveState(ActivityDataSyncState(deviceID: "stale"))
- let stale = try aggregate(0, directory: directory).syncedAggregate
+ let stale = aggregate(0).syncedAggregate
let record = try ActivityDataSyncRecord(deviceID: "stale", activityData: stale, recordName: ActivityDataSyncRecord.recordName(deviceID: "stale", date: stale.date))
try store.saveFetchedRecords([record.id: record], cursor: nil)
let blocked = directory.url.appendingPathComponent("tokenUsage/store.lock")
try FileManager.default.createDirectory(at: blocked, withIntermediateDirectories: true)
- _ = try await service(database, directory).synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0, directory: directory)], trigger: .manual)
+ _ = await service(database, directory).synchronizeIfEnabled(localActivityDataAggregates: [aggregate(0)], trigger: .manual)
#expect(store.loadState().deviceID == nil)
#expect(try store.load().records.isEmpty)
#expect(await database.creations == 0)
try FileManager.default.removeItem(at: blocked)
- let snapshot = try await service(database, directory).synchronizeIfEnabled(
- localActivityDataAggregates: [aggregate(0, directory: directory)],
+ let snapshot = await service(database, directory).synchronizeIfEnabled(
+ localActivityDataAggregates: [aggregate(0)],
localTokenUsageAggregates: [turn(0)],
trigger: .manual
)
@@ -219,8 +219,8 @@ struct ZoneRecoveryTests {
SyncService(database: database, directoryURL: directory.url, isEnabled: { true })
}
- private func aggregate(_ index: Int, events: Int = 1, directory: TestDirectory) throws -> ActivityDataAggregate {
- try directory.activityDataAggregate(date: HistoryStorage.dateKey(for: Date().addingTimeInterval(Double(-index) * 86400)), events: events)
+ private func aggregate(_ index: Int, events: Int = 1) -> ActivityDataAggregate {
+ TestFixtures.activityDataAggregate(date: HistoryStorage.dateKey(for: Date().addingTimeInterval(Double(-index) * 86400)), events: events)
}
private func turn(_ index: Int, tokens: Int = 1) -> TokenUsageAggregate {