Skip to content

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

41.5 KB
Raw Blame
import Combine
import Foundation
import os
import SQLite3
import Testing

@Suite(.tags(.integration))
struct AppServerLogTests {
    @Test func closeDrainsWritesAndPermanentlyClosesDatabase() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: "before cleanup")
        _ = try await storage.page()
        #expect(try !directory.openFilePaths().isEmpty)
        storage.recordFailure(message: "queued before cleanup")
        let requestID = storage.beginRequest(method: "last", payload: "{}")
        storage.finishRequest(requestID, response: "saved")
        try await storage.close()
        try await storage.close()
        #expect(try directory.openFilePaths().isEmpty)
        await #expect(throws: AppServerLogStore.LifecycleError.closed) { try await storage.page() }
        await #expect(throws: AppServerLogStore.LifecycleError.closed) { try await storage.changes(since: 0) }
        await #expect(throws: AppServerLogStore.LifecycleError.closed) { try await storage.clear() }
        #expect(try directory.openFilePaths().isEmpty)
        storage.recordFailure(message: "after cleanup")
        try await storage.close()
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let page = try await reopened.page()
        #expect(page.total == 3)
        #expect(page.entries.first { $0.id == requestID }?.detail == "saved")
        #expect(page.entries.filter { $0.id != requestID }.map(\.detail) == ["queued before cleanup", "before cleanup"])
    }

    @Test func closePersistsSkippedWriteCountBeforeReleasingConnection() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(bytes: 4096))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: String(repeating: "a", count: 8192))
        try await storage.close()
        #expect(try directory.openFilePaths().isEmpty)
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let page = try await reopened.page()
        #expect(page.total == 1)
        #expect(page.entries.first?.method == "log/backpressure")
        #expect(page.entries.first?.detail == "Skipped 1 log entries because the write buffer was full")
    }

    @Test(arguments: [false, true])
    func stoppingDuringFirstReadDiscardsResultsAndAllowsReopening(reopenImmediately: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let writer = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await writer.close() } }
        writer.recordFailure(message: "saved log")
        _ = try await writer.page()

        let reads = OSAllocatedUnfairLock(initialState: 0)
        let release = DispatchSemaphore(value: 0)
        let storage = AppServerLogStore(directoryURL: directory.url, now: {
            let firstRead = reads.withLock { count in
                count += 1
                return count == 1
            }
            if firstRead {
                // 仅暂停存储队列, 让主 actor 能在读取完成前关闭窗口
                #expect(release.wait(timeout: .now() + 5) == .success)
            }
            return Date()
        })
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        defer { release.signal() }
        let model = AppServerLogViewModel(storage: storage)
        defer { model.stop() }
        let firstRead = Task { await model.refresh() }
        defer { firstRead.cancel() }
        for _ in 0 ..< 200 where reads.withLock({ $0 }) == 0 {
            try await Task.sleep(for: .milliseconds(5))
        }
        try #require(reads.withLock { $0 } > 0)
        #expect(model.isLoading)

        model.stop()
        #expect(!model.isLoading)
        #expect(model.entries.isEmpty)
        if reopenImmediately {
            model.start()
        }
        release.signal()
        await firstRead.value
        if !reopenImmediately {
            #expect(!model.isLoading)
            #expect(model.entries.isEmpty)
            #expect(model.totalCount == 0)
            model.start()
        }

        for _ in 0 ..< 200 where model.entries.isEmpty || model.isLoading {
            try await Task.sleep(for: .milliseconds(5))
        }
        #expect(!model.isLoading)
        #expect(model.totalCount == 1)
        #expect(model.entries.first?.detail == "saved log")
        #expect(model.errorMessage == nil)
    }

    @Test func startingObservationDuringFirstReadCompletesLoading() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: "startup log")
        let model = AppServerLogViewModel(storage: storage)
        defer { model.stop() }

        // 固定调用顺序, 复现视图先读取, 窗口随后开始观察的情况
        var didStart = false
        let subscription = model.$isLoading.sink { isLoading in
            guard isLoading, !didStart else { return }
            didStart = true
            model.start()
        }
        defer { subscription.cancel() }

        await model.refresh()
        #expect(didStart)
        #expect(!model.isLoading)
        #expect(model.totalCount == 1)
        #expect(model.entries.first?.detail == "startup log")
        #expect(model.errorMessage == nil)
        #expect(try await storage.page().total == 1)

        await model.refresh()
        #expect(!model.isLoading)
        #expect(model.entries.count == 1)

        model.stop()
        await model.refresh()
        #expect(!model.isLoading)
        #expect(model.entries.first?.detail == "startup log")
    }

    @Test func unsupportedDatabaseVersionRejectsWritesAndClear() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let url = directory.url.appendingPathComponent(AppServerLogStore.databaseName)
        var database: OpaquePointer?
        #expect(sqlite3_open(url.path, &database) == SQLITE_OK)
        #expect(sqlite3_exec(database, "PRAGMA user_version = 999; CREATE TABLE future_data (value TEXT); INSERT INTO future_data VALUES ('keep');", nil, nil, nil) == SQLITE_OK)
        sqlite3_close(database)
        let before = try Data(contentsOf: url)
        let store = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await store.close() } }
        store.recordFailure(message: "must not be written")
        await #expect(throws: (any Error).self) { try await store.page() }
        await #expect(throws: (any Error).self) { try await store.clear() }
        await #expect(throws: (any Error).self) { try await store.close() }
        #expect(try Data(contentsOf: url) == before)
    }

    @Test(arguments: [0, 5])
    func unchangedRefreshDoesNotPublishOrChangePaging(entryCount: Int) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< entryCount {
            storage.recordFailure(message: "entry-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2)
        await model.refresh()
        let entries = model.entries
        let hasMore = model.hasMore
        var publications = 0
        let subscription = model.objectWillChange.sink { publications += 1 }
        defer { subscription.cancel() }

        for _ in 0 ..< 3 {
            await model.refresh()
        }
        #expect(publications == 0)
        #expect(model.entries == entries)
        #expect(model.totalCount == entryCount)
        #expect(model.hasMore == hasMore)
        #expect(!model.isLoading)

        let request = storage.beginRequest(method: "new", payload: "{}")
        await model.refresh()
        #expect(model.entries.first?.id == request)
        storage.finishRequest(request, response: "response")
        await model.refresh()
        #expect(model.entries.first?.status == .success)
        #expect(model.entries.first?.detail == "response")
        #expect(publications > 0)
    }

    @Test func unchangedRevisionStillClearsRecoveredReadError() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: "existing")
        let model = AppServerLogViewModel(storage: storage)
        await model.refresh()
        let entries = model.entries
        var database: OpaquePointer?
        #expect(sqlite3_open(directory.url.appendingPathComponent(AppServerLogStore.databaseName).path, &database) == SQLITE_OK)
        defer { sqlite3_close(database) }
        #expect(sqlite3_exec(database, "ALTER TABLE metadata RENAME TO hidden_metadata", nil, nil, nil) == SQLITE_OK)
        await model.refresh()
        #expect(model.errorMessage != nil)
        var publications = 0
        let subscription = model.objectWillChange.sink { publications += 1 }
        defer { subscription.cancel() }

        await model.refresh()
        #expect(publications == 0)
        #expect(sqlite3_exec(database, "ALTER TABLE hidden_metadata RENAME TO metadata", nil, nil, nil) == SQLITE_OK)
        await model.refresh()
        #expect(model.errorMessage == nil)
        #expect(model.entries == entries)
        #expect(publications == 1)
        await model.refresh()
        #expect(publications == 1)
    }

    @Test(arguments: [false, true])
    func retentionKeepsBrowsedEntriesUntilReturningToLatest(loadNextPage: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(entries: 6))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 6 {
            storage.recordFailure(message: "old-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2, maximumEntries: 2)
        await model.refresh()
        await model.loadMore()
        let browsedEntries = model.entries
        #expect(browsedEntries.map(\.detail) == ["old-3", "old-2"])
        for index in 0 ..< 4 {
            storage.recordFailure(message: "new-\(index)")
        }
        let retained = try await storage.page()
        #expect(Set(retained.entries.map(\.id)).isDisjoint(with: browsedEntries.map(\.id)))
        #expect(retained.total <= 6)
        if loadNextPage {
            await model.loadMore()
        } else {
            await model.refresh()
        }
        #expect(model.entries == browsedEntries)
        #expect(!model.hasMore)
        await model.refresh()
        #expect(model.entries == browsedEntries)
        #expect(model.totalCount == retained.total)
        await model.resumeFollowingLatest()
        #expect(model.entries.first?.detail == "new-3")
        #expect(model.entries.count == 2)
    }

    @Test(arguments: [false, true])
    func retentionPreservesUntrimmedBrowsingAndExplicitClearStillEmptiesIt(filtered: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(entries: 6))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 6 {
            storage.recordFailure(method: "kept", message: "old-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2)
        if filtered {
            model.setSelectedMethods(["kept"])
        }
        await model.refresh()
        model.pauseFollowingLatest()
        await model.loadMore()
        let browsedEntries = model.entries
        #expect(browsedEntries.count == 4)
        for index in 0 ..< 4 {
            storage.recordFailure(method: "kept", message: "new-\(index)")
        }
        await model.refresh()
        #expect(model.entries == browsedEntries)
        #expect(!model.hasMore)
        #expect(model.totalCount <= 6)
        #expect(try await storage.page().entries != browsedEntries)
        await model.clear()
        #expect(model.entries.isEmpty)
        #expect(model.totalCount == 0)
        #expect(!model.hasMore)
        storage.recordFailure(method: "kept", message: "after clear")
        await model.refresh()
        #expect(model.entries.first?.detail == "after clear")
    }

    @Test func expiredBrowsingSnapshotCanStillBeExplicitlyCleared() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let time = OSAllocatedUnfairLock(initialState: Date())
        let storage = AppServerLogStore(directoryURL: directory.url, now: { time.withLock { $0 } })
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: "expires while reading")
        let model = AppServerLogViewModel(storage: storage)
        await model.refresh()
        model.pauseFollowingLatest()
        let browsedEntries = model.entries
        time.withLock { $0 = $0.addingTimeInterval(366 * 86400) }
        await model.refresh()
        #expect(model.totalCount == 0)
        #expect(model.entries == browsedEntries)
        #expect(!model.hasMore)
        await model.clear()
        #expect(model.entries.isEmpty)
        #expect(model.totalCount == 0)
    }

    @Test(arguments: [2, 1000])
    func browsingKeepsLoadedEntriesWhenLiveChangesAccumulate(changeLimit: Int) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(pageEntries: changeLimit))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 6 {
            storage.recordFailure(message: "old-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2, maximumEntries: 6)
        await model.refresh()
        model.pauseFollowingLatest()
        await model.loadMore()
        let browsedEntries = model.entries
        for index in 0 ..< 5 {
            storage.recordFailure(message: "new-\(index)")
        }
        await model.refresh()
        #expect(model.entries == browsedEntries)
        #expect(model.hasMore)
        await model.resumeFollowingLatest()
        #expect(model.entries.first?.detail == "new-4")
        #expect(model.entries.count == 2)
        storage.recordFailure(message: "following again")
        await model.refresh()
        #expect(model.entries.first?.detail == "following again")
    }

    @Test func beginningToBrowseDuringRetentionReloadPreservesTheCurrentPage() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let blocked = OSAllocatedUnfairLock(initialState: (readsUntilBlock: 0, didBlock: false))
        let release = DispatchSemaphore(value: 0)
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(entries: 4), now: {
            let shouldBlock = blocked.withLock { state in
                guard state.readsUntilBlock > 0 else { return false }
                state.readsUntilBlock -= 1
                guard state.readsUntilBlock == 0 else { return false }
                state.didBlock = true
                return true
            }
            if shouldBlock {
                #expect(release.wait(timeout: .now() + 5) == .success)
            }
            return Date()
        })
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        defer { release.signal() }
        for index in 0 ..< 4 {
            storage.recordFailure(message: "old-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2)
        await model.refresh()
        let browsedEntries = model.entries
        for index in 0 ..< 4 {
            storage.recordFailure(message: "new-\(index)")
        }
        _ = try await storage.page()
        blocked.withLock { $0.readsUntilBlock = 2 }
        let refresh = Task { await model.refresh() }
        defer { refresh.cancel() }
        try #require(try await waitForCondition(timeout: .seconds(1), pollInterval: .milliseconds(5)) {
            blocked.withLock { $0.didBlock }
        })
        model.pauseFollowingLatest()
        release.signal()
        await refresh.value
        #expect(model.entries == browsedEntries)
        await model.refresh()
        #expect(model.entries == browsedEntries)
        #expect(!model.hasMore)
        await model.resumeFollowingLatest()
        #expect(model.entries.first?.detail == "new-3")
    }

    @Test func retentionChangeReloadsWhenFollowingLatest() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(entries: 4))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 4 {
            storage.recordFailure(message: "old-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 2)
        await model.refresh()
        await model.loadMore()
        let previousIDs = Set(model.entries.map(\.id))
        for index in 0 ..< 8 {
            storage.recordFailure(message: "new-\(index)")
        }
        await model.refresh()
        #expect(model.entries.count == 2)
        #expect(model.entries.first?.detail == "new-7")
        #expect(previousIDs.isDisjoint(with: model.entries.map(\.id)))
        #expect(model.totalCount <= 4)
        while model.hasMore {
            await model.loadMore()
        }
        #expect(model.entries.count == model.totalCount)
        await model.clear()
        await model.refresh()
        #expect(model.entries.isEmpty)
        #expect(!model.hasMore)
        #expect(model.totalCount == 0)
    }

    @Test func corruptPendingRowPreservesPagingAppendAndClear() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let first = storage.beginRequest(method: "healthy", payload: "{}")
        storage.finishRequest(first, response: "ok")
        let broken = storage.beginRequest(method: "broken", payload: "{}")
        _ = try await storage.page()
        var database: OpaquePointer?
        #expect(sqlite3_open(directory.url.appendingPathComponent(AppServerLogStore.databaseName).path, &database) == SQLITE_OK)
        defer { sqlite3_close(database) }
        #expect(sqlite3_exec(database, "UPDATE entries SET payload = x'7B' WHERE id = '\(broken.uuidString)'", nil, nil, nil) == SQLITE_OK)
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let page = try await reopened.page(limit: 1)
        #expect(page.entries.first?.id == broken)
        #expect(page.entries.first?.method == "log/corrupt")
        #expect(page.entries.first?.detail?.hasSuffix("{") == true)
        #expect(page.hasMore)
        let next = try await reopened.page(before: #require(page.entries.first?.position), limit: 1)
        #expect(next.entries.first?.id == first)
        #expect(!next.hasMore)
        reopened.recordFailure(message: "still writes")
        #expect(try await reopened.page().total == 3)
        let again = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await again.close() } }
        #expect(try await again.page().entries.first(where: { $0.id == broken })?.detail == page.entries.first?.detail)
        try await again.clear()
        #expect(try await again.page().total == 0)
    }

    @Test func persistsBeyondFiveHundredAndRestoresOriginalPayloads() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 625 {
            let id = storage.beginRequest(method: "probe/\(index)", payload: "{\"secret\":\"unchanged\",\"index\":\(index)}", connection: "activity")
            storage.finishRequest(id, response: " response \(index)\n")
        }
        let page = try await storage.page(limit: 100)
        #expect(page.total == 625)
        #expect(page.entries.count == 100)
        #expect(page.entries.first?.method == "probe/624")
        #expect(page.entries.first?.detail == " response 624\n")
        #expect(page.hasMore)
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let restored = try await reopened.page(limit: 700)
        #expect(restored.total == 625)
        #expect(restored.entries.count == 625)
        #expect(restored.entries.first?.request == "{\"secret\":\"unchanged\",\"index\":624}")
        #expect(restored.entries.last?.method == "probe/0")
        #expect(restored.entries.allSatisfy { $0.status == .success && $0.connection == "activity" })
    }

    @Test func cursorRemainsStableWhileNewRequestsAndOldResponsesArrive() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        var ids: [UUID] = []
        for index in 0 ..< 12 {
            ids.append(storage.beginRequest(method: "probe/\(index)", payload: "{}"))
        }
        let first = try await storage.page(limit: 5)
        let cursor = try #require(first.entries.last?.position)
        storage.finishRequest(ids[0], response: "late")
        let newest = storage.beginRequest(method: "new", payload: "{}")
        let second = try await storage.page(before: cursor, limit: 5)
        let third = try await storage.page(before: #require(second.entries.last?.position), limit: 5)
        let historical = first.entries + second.entries + third.entries
        #expect(Set(historical.map(\.id)) == Set(ids))
        #expect(historical.count == 12)
        #expect(!third.hasMore)
        #expect(third.entries.last?.detail == "late")
        let changes = try await storage.changes(since: first.revision)
        #expect(Set(changes.entries.map(\.id)) == Set([ids[0], newest]))
    }

    @Test func clearDoesNotResurrectAnInflightRequestAndPersists() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let pending = storage.beginRequest(method: "old", payload: "{}")
        let before = try await storage.page()
        try await storage.clear()
        storage.finishRequest(pending, response: "late response")
        let new = storage.beginRequest(method: "new", payload: "{}")
        storage.finishRequest(new, response: "done")
        let after = try await storage.page()
        #expect(after.total == 1)
        #expect(after.entries.first?.id == new)
        #expect(after.generation > before.generation)
        #expect(after.entries.first?.position ?? 0 > before.entries.first?.position ?? 0)
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        #expect(try await reopened.page().entries.map(\.id) == [new])
    }

    @Test func unfinishedPreviousRunIsNotShownAsWaitingForever() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        var writer: AppServerLogStore? = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await writer?.close() } }
        let id = try #require(writer).beginRequest(method: "unfinished", payload: "{}")
        _ = try await writer?.page()
        writer = nil
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let entry = try #require(try await reopened.page().entries.first)
        #expect(entry.id == id)
        #expect(entry.status == .failure)
        #expect(entry.respondedAt == nil)
        #expect(entry.request == "{}")
        #expect(entry.detail != nil)
    }

    @Test func viewMergesLiveUpdatesWithoutDroppingLoadedHistory() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        var ids: [UUID] = []
        for index in 0 ..< 9 {
            ids.append(storage.beginRequest(method: "probe/\(index)", payload: "{}"))
        }
        let store = AppServerLogViewModel(storage: storage, pageSize: 3)
        await store.refresh()
        #expect(store.entries.count == 3)
        #expect(store.totalCount == 9)
        await store.loadMore()
        let position = store.entries.last?.position
        storage.finishRequest(ids[3], response: "updated")
        let new = storage.beginRequest(method: "new", payload: "{}")
        await store.refresh()
        #expect(store.entries.count == 7)
        #expect(store.entries.first?.id == new)
        #expect(store.entries.last?.position == position)
        #expect(store.entries.last?.detail == "updated")
        await store.loadMore()
        #expect(store.entries.count == 10)
        #expect(Set(store.entries.map(\.id)).count == 10)
        #expect(!store.hasMore)
        await store.clear()
        #expect(store.entries.isEmpty)
        #expect(store.totalCount == 0)
        storage.recordFailure(message: "new failure")
        await store.refresh()
        #expect(store.entries.count == 1)
    }

    @Test func storageFailureIsVisibleAndDoesNotBreakRequestRecordingCallers() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let file = try directory.write("not a directory", to: "blocked")
        let storage = AppServerLogStore(directoryURL: file)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordFailure(message: "recording remains nonthrowing")
        let store = AppServerLogViewModel(storage: storage)
        await store.refresh()
        #expect(store.errorMessage != nil)
        #expect(store.entries.isEmpty)
        await #expect(throws: (any Error).self) { try await storage.close() }
        #expect(try directory.openFilePaths().isEmpty)
    }
}

extension AppServerLogTests {
    @Test(arguments: [65537, 131072, 131073])
    func defaultBodyLimitPreservesLargePayloadsAndTruncatesOverflow(bodyBytes: Int) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let payload = String(repeating: "a", count: bodyBytes - 4) + "🙂"
        let id = storage.beginRequest(method: "large/request", payload: payload)
        storage.finishRequest(id, response: payload)
        storage.recordReceived(method: "large/event", payload: payload, connection: "activity")
        try await storage.close()

        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        let page = try await reopened.page()
        let request = try #require(page.entries.first { $0.id == id })
        let event = try #require(page.entries.first { $0.method == "large/event" })
        for (text, originalBytes) in [
            (request.request, request.requestOriginalBytes),
            (request.detail, request.detailOriginalBytes),
            (event.detail, event.detailOriginalBytes)
        ] {
            let text = try #require(text)
            if bodyBytes <= 128 * 1024 {
                #expect(text == payload)
                #expect(originalBytes == nil)
            } else {
                #expect(text.utf8.count <= 128 * 1024)
                #expect(text.hasSuffix("[Truncated, original: \(bodyBytes) bytes]"))
                #expect(!text.contains("�"))
                #expect(originalBytes == bodyBytes)
            }
        }
    }

    @Test func retentionPrunesOldPendingRequestsAndLateRepliesStayDeleted() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(entries: 10))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let first = storage.beginRequest(method: "old", payload: "{}")
        let initial = try await storage.page()
        for index in 0 ..< 40 {
            storage.recordFailure(message: "failure-\(index)")
        }
        let retained = try await storage.page()
        #expect(retained.total <= 10)
        #expect(retained.entries.first?.detail == "failure-39")
        #expect(!retained.entries.contains { $0.id == first })
        #expect(retained.generation > initial.generation)
        storage.finishRequest(first, response: "late")
        #expect(try await storage.page().total == retained.total)
    }

    @Test func byteLimitAndUnicodeBodyTruncationAreBoundedAcrossReopen() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let limits = AppServerLogStore.Limits(entries: 100, bytes: 4096, bodyBytes: 256, pageEntries: 10)
        let storage = AppServerLogStore(directoryURL: directory.url, limits: limits)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let text = String(repeating: "你好🙂", count: 300)
        for index in 0 ..< 30 {
            let id = storage.beginRequest(method: "large-\(index)", payload: text)
            _ = try await storage.page()
            storage.finishRequest(id, response: text)
            _ = try await storage.page()
        }
        let page = try await storage.page(limit: 100)
        #expect(page.total < 30)
        #expect(page.entries.count <= 10)
        for entry in page.entries {
            #expect(entry.requestOriginalBytes == text.utf8.count)
            #expect(entry.detailOriginalBytes == text.utf8.count)
            #expect((entry.request?.utf8.count ?? 0) <= 256)
            #expect((entry.detail?.utf8.count ?? 0) <= 256)
            #expect(entry.request?.contains("Truncated") == true)
            #expect(entry.request?.contains("�") == false)
        }
        try await storage.close()
        let reopened = AppServerLogStore(directoryURL: directory.url, limits: limits)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        #expect(try await reopened.page().total == page.total)
        let size = try directory.url.appendingPathComponent(AppServerLogStore.databaseName)
            .resourceValues(forKeys: [.fileSizeKey]).fileSize ?? 0
        #expect(size < 128 * 1024)
    }

    @Test(arguments: [false, true])
    func returningToTopRestoresLatestAfterHistoryEviction(addNewEntry: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 9 {
            storage.recordFailure(message: "entry-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 3, maximumEntries: 6)
        await model.refresh()
        await model.loadMore()
        await model.loadMore()
        #expect(model.entries.first?.detail == "entry-5")
        if addNewEntry {
            storage.recordFailure(message: "latest")
        }
        await model.refresh()
        #expect(model.entries.first?.detail == "entry-5")
        await model.resumeFollowingLatest()
        #expect(model.entries.first?.detail == (addNewEntry ? "latest" : "entry-8"))
        #expect(model.entries.count == 3)
        #expect(model.hasMore)
        #expect(model.totalCount == (addNewEntry ? 10 : 9))
        #expect(!model.isLoading)
        #expect(model.errorMessage == nil)

        storage.recordFailure(message: "following again")
        await model.refresh()
        #expect(model.entries.first?.detail == "following again")
        #expect(model.entries.count == 4)
        await model.loadMore()
        #expect(model.entries.count == 6)
        #expect(Set(model.entries.map(\.id)).count == 6)
    }

    @Test func returningToTopPreservesHistoryWhenLatestIsStillLoaded() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        for index in 0 ..< 9 {
            storage.recordFailure(message: "entry-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 3, maximumEntries: 6)
        await model.refresh()
        await model.loadMore()
        let entries = model.entries
        model.pauseFollowingLatest()
        await model.resumeFollowingLatest()
        #expect(model.entries == entries)
        #expect(model.entries.count == 6)
        #expect(model.entries.first?.detail == "entry-8")
    }

    @Test(arguments: [false, true])
    func returningToTopWaitsForPagingAndDiscardsStoppedObservation(stopWhileWaiting: Bool) async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let readGate = AppServerLogReadGate()
        let storage = AppServerLogStore(directoryURL: directory.url, now: { readGate.now() })
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        defer { readGate.release() }
        for index in 0 ..< 9 {
            storage.recordFailure(message: "entry-\(index)")
        }
        let model = AppServerLogViewModel(storage: storage, pageSize: 3, maximumEntries: 6)
        defer { model.stop() }
        await model.refresh()
        await model.loadMore()
        readGate.arm()
        let pagination = Task { await model.loadMore() }
        defer { pagination.cancel() }
        try #require(try await waitForCondition(timeout: .seconds(1), pollInterval: .milliseconds(5)) {
            readGate.didBlock
        })
        var didRequestLatest = false
        let returnToTop = Task {
            didRequestLatest = true
            await model.resumeFollowingLatest()
        }
        defer { returnToTop.cancel() }
        try #require(try await waitForCondition(timeout: .seconds(1), pollInterval: .milliseconds(5)) {
            didRequestLatest
        })
        if stopWhileWaiting {
            model.stop()
        }
        readGate.release()
        await pagination.value
        await returnToTop.value
        #expect(!model.isLoading)
        if stopWhileWaiting {
            #expect(model.entries.isEmpty)
            #expect(model.totalCount == 0)
        } else {
            #expect(model.entries.first?.detail == "entry-8")
            #expect(model.entries.count == 3)
            #expect(model.totalCount == 9)
        }
    }

    @Test func changeOverflowReloadsAndHistoryWindowRemainsBounded() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url, limits: .init(pageEntries: 5))
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let model = AppServerLogViewModel(storage: storage, pageSize: 3, maximumEntries: 6)
        await model.refresh()
        for index in 0 ..< 20 {
            storage.recordFailure(message: "entry-\(index)")
        }
        await model.refresh()
        #expect(model.entries.count == 3)
        #expect(model.entries.first?.detail == "entry-19")
        var visited = Set(model.entries.map(\.id))
        while model.hasMore {
            await model.loadMore()
            #expect(model.entries.count <= 6)
            visited.formUnion(model.entries.map(\.id))
        }
        #expect(visited.count == 20)
        #expect(model.entries.count == 6)
        let historyIDs = model.entries.map(\.id)
        storage.recordFailure(message: "latest")
        await model.refresh()
        #expect(model.entries.count <= 6)
        #expect(model.entries.map(\.id) == historyIDs)
        model.stop()
        #expect(model.entries.isEmpty)
        storage.recordFailure(message: "closed-window failure")
        await model.refresh()
        #expect(model.entries.count == 3)
        #expect(model.totalCount == 22)
        #expect(model.entries.first?.detail == "closed-window failure")
        #expect(model.entries.contains { $0.detail == "latest" })
    }
}

extension AppServerLogTests {
    @Test func requestSourceSurvivesBothSuccessfulAndFailedCompletion() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let success = storage.beginRequest(method: "success", payload: "{}")
        let failure = storage.beginRequest(method: "failure", payload: "{}")
        let pending = try await storage.page().entries
        #expect(pending.allSatisfy { $0.source == .request && $0.status == .pending })
        storage.finishRequest(success, response: "{}")
        storage.failRequest(failure, message: "timeout")
        let completed = try await storage.page().entries
        #expect(completed.count == 2)
        #expect(completed.allSatisfy { $0.source == .request })
        #expect(completed.first { $0.id == success }?.status == .success)
        #expect(completed.first { $0.id == failure }?.status == .failure)
    }

    @Test func messageDirectionAndLocalErrorsHaveIndependentStatuses() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        storage.recordSent(method: "initialized", payload: "{}")
        storage.recordSent(method: "websocket/pong", payload: "ping", error: "disconnected")
        storage.recordReceived(method: "turn/completed", payload: #"{"status":"failed"}"#, connection: "activity")
        storage.recordFailure(method: "activity/storage", message: "disk full")
        let entries = try await storage.page().entries
        #expect(entries.first { $0.method == "initialized" }?.source == .sent)
        #expect(entries.first { $0.method == "initialized" }?.status == .success)
        #expect(entries.first { $0.method == "websocket/pong" }?.source == .sent)
        #expect(entries.first { $0.method == "websocket/pong" }?.status == .failure)
        #expect(entries.first { $0.method == "turn/completed" }?.source == .received)
        #expect(entries.first { $0.method == "turn/completed" }?.status == .information)
        #expect(entries.first { $0.method == "activity/storage" }?.source == .local)
        #expect(entries.first { $0.method == "activity/storage" }?.status == .failure)
    }

    @Test func connectionAttemptFinishesInPlaceAndClosedConnectionIsInformational() async throws {
        let directory = try TestDirectory()
        defer { try? directory.remove() }
        let storage = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await storage.close() } }
        let attempt = storage.recordConnection(method: "connection/open", detail: "socket", connection: "activity", status: .pending)
        #expect(try await storage.page().entries.first?.status == .pending)
        storage.finishRequest(attempt, response: "socket")
        let handshake = storage.beginRequest(method: "websocket/handshake", payload: "GET /", source: .connection)
        storage.failRequest(handshake, message: "handshake failed")
        storage.recordConnection(method: "connection/closed", detail: "socket", connection: "activity", status: .information)
        let entries = try await storage.page().entries
        #expect(entries.allSatisfy { $0.source == .connection })
        #expect(entries.first { $0.id == attempt }?.status == .success)
        #expect(entries.first { $0.id == handshake }?.status == .failure)
        #expect(entries.first { $0.method == "connection/closed" }?.status == .information)
        let reopened = AppServerLogStore(directoryURL: directory.url)
        defer { await #expect(throws: Never.self) { try await reopened.close() } }
        #expect(try await reopened.page().entries == entries)
    }
}