mirror of
https://github.com/wu736139669/hapi.git
synced 2026-10-24 22:10:59 +00:00
315 lines
17 KiB
Swift
315 lines
17 KiB
Swift
import HapiClient
|
|
@testable import HapiProtocol
|
|
import Observation
|
|
import SwiftUI
|
|
import UIKit
|
|
import XCTest
|
|
@testable import Hapi
|
|
@testable import HapiUI
|
|
|
|
/// Real native question cards with deterministic data, no live conversations.
|
|
@MainActor
|
|
final class QuestionCardPresentationTests: XCTestCase {
|
|
private static let input = #"{"questions":[{"id":"skill","header":"超能力选择","question":"如果能瞬间学会一项技能，你最想选哪个？","options":[{"label":"精通一门外语 (Recommended)","description":"旅行、看剧、交流都不再有语言障碍。"},{"label":"精通一种乐器","description":"随时演奏自己喜欢的音乐。"},{"label":"拥有顶级厨艺","description":"想吃什么美食，都能自己做出来。"}]}]}"#
|
|
|
|
private struct NoHTTP: HTTPPerforming {
|
|
func perform(_ request: URLRequest) async throws -> (Data, HTTPURLResponse) {
|
|
throw URLError(.notConnectedToInternet)
|
|
}
|
|
}
|
|
|
|
@Observable @MainActor
|
|
final class Driver {
|
|
var tool: ChatToolCall
|
|
let presentation = ChatPresentationState()
|
|
let interactor: ChatInteractor
|
|
@ObservationIgnored var height: CGFloat = 0
|
|
init(tool: ChatToolCall) {
|
|
self.tool = tool
|
|
let url = URL(string: "http://127.0.0.1:1")!
|
|
let auth = AuthManager(baseURL: url, credentialStore: InMemoryCredentialStore(), performer: NoHTTP())
|
|
let api = APIClient(baseURL: url, authManager: auth, performer: NoHTTP())
|
|
interactor = ChatInteractor(sessionId: "question-specimen", api: api,
|
|
sessionStore: SessionListStore(api: api), windows: MessageWindowControllers(provider: api))
|
|
}
|
|
|
|
var block: ToolCallBlock {
|
|
ToolCallBlock(id: tool.id, localId: nil, createdAt: 0, invokedAt: nil, durationMs: nil,
|
|
usage: nil, model: nil, tool: tool, children: [], meta: nil)
|
|
}
|
|
|
|
var draft: QuestionAnswerDraft {
|
|
get { presentation.values[.init(id: "reply", field: QuestionAnswerDraft.storageField)] as? QuestionAnswerDraft ?? .init() }
|
|
set { presentation.values[.init(id: "reply", field: QuestionAnswerDraft.storageField)] = newValue }
|
|
}
|
|
}
|
|
|
|
private struct Card: View {
|
|
let driver: Driver
|
|
var body: some View {
|
|
ToolCallBlockView(block: driver.block, basePath: nil)
|
|
.environment(\.chatInteractions, driver.interactor)
|
|
.environment(\.chatPresentationState, driver.presentation)
|
|
.background(GeometryReader { geometry in
|
|
Color.clear
|
|
.onAppear { driver.height = geometry.size.height }
|
|
.onChange(of: geometry.size.height) { _, height in driver.height = height }
|
|
})
|
|
.hapiReadingColumn()
|
|
}
|
|
}
|
|
|
|
private struct Specimen: View {
|
|
let driver: Driver
|
|
let theme: HapiTheme
|
|
let typeSize: DynamicTypeSize
|
|
var body: some View {
|
|
NavigationStack {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 20) {
|
|
UserTextBlockView(block: UserTextBlock(
|
|
id: "user", localId: nil, createdAt: 0, invokedAt: nil,
|
|
text: "再问我一个问题", attachments: nil, status: nil, originalText: nil, meta: nil
|
|
)).hapiReadingColumn()
|
|
Card(driver: driver)
|
|
}
|
|
.padding(.vertical, 16)
|
|
}
|
|
.background(theme.background)
|
|
.safeAreaInset(edge: .bottom, spacing: 0) { ChatComposerView(interactor: driver.interactor) }
|
|
.navigationTitle("问答测试")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
}
|
|
.hapiTheme(theme)
|
|
.hapiTypography()
|
|
.environment(\.dynamicTypeSize, typeSize)
|
|
.preferredColorScheme(theme.isDark ? .dark : .light)
|
|
}
|
|
}
|
|
|
|
private func makeTool(_ input: String = QuestionCardPresentationTests.input) throws -> ChatToolCall {
|
|
ChatToolCall(id: "question", name: "functions.request_user_input", state: .running,
|
|
input: try JSONDecoder().decode(JSONValue.self, from: Data(input.utf8)), createdAt: 0,
|
|
permission: ToolPermission(id: "reply", status: .pending))
|
|
}
|
|
|
|
func testOtherNotesStayOnTheCurrentQuestionAndRenderRecordedAnswers() async throws {
|
|
let source = #"{"questions":[{"id":"choice","header":"选择","question":"请选择一项","isOther":true,"options":[{"label":"Alpha"},{"label":"Beta"}]},{"id":"last","question":"Next question","options":[{"label":"Finish"}]}]}"#
|
|
for (name, theme, size, width) in [("light", HapiTheme.light, DynamicTypeSize.large, CGFloat(390)),
|
|
("large-type", .dark, .accessibility3, 320)] {
|
|
let driver = Driver(tool: try makeTool(source))
|
|
let (window, _) = try host(Specimen(driver: driver, theme: theme, typeSize: size), width: width)
|
|
defer { window.isHidden = true }
|
|
try await settle { driver.height > 100 }
|
|
let initialHeight = driver.height
|
|
let form = QuestionAnswerForm(tool: driver.tool)
|
|
driver.draft.select(2, at: 0, in: form)
|
|
XCTAssertEqual(driver.draft.page, 0)
|
|
XCTAssertTrue(driver.draft.isAnswered(at: 0, in: form))
|
|
try await settle { driver.height > initialHeight }
|
|
driver.draft.setText("自定义\n说明", at: 0, in: form)
|
|
driver.tool.description = "Unrelated SSE update"
|
|
try await Task.sleep(for: .milliseconds(150))
|
|
XCTAssertEqual(driver.draft.selections[0], [2])
|
|
XCTAssertEqual(driver.draft.text(at: 0, in: form), "自定义\n说明")
|
|
XCTAssertFalse(questionToolDetails(driver.tool).hasAnswers)
|
|
try capture(window, name: "other-notes-\(name)")
|
|
driver.tool.state = .completed
|
|
driver.tool.permission = ToolPermission(id: "reply", status: .resolved)
|
|
XCTAssertFalse(questionToolDetails(driver.tool).hasAnswers, "Resolution does not prove which answer won")
|
|
driver.tool.result = .object(["answers": .object(["choice": .object([
|
|
"answers": .array([.string("None of the above"), .string("user_note: 自定义\n说明")]),
|
|
])])])
|
|
try await settle { driver.height < initialHeight }
|
|
let details = questionToolDetails(driver.tool)
|
|
XCTAssertEqual(details.questions[0].options.map(\.selected), [false, false, true])
|
|
XCTAssertEqual(details.questions[0].note, "自定义\n说明")
|
|
}
|
|
}
|
|
|
|
func testQuestionCardsFitThemesAndTypeSizesAndCollapseOnlyWithRecordedAnswers() async throws {
|
|
for (name, theme, size, width) in [
|
|
("light", HapiTheme.light, DynamicTypeSize.large, CGFloat(390)),
|
|
("dark", .dark, .large, 390), ("oled", .oled, .large, 390),
|
|
("small", .light, .large, 320), ("large-type", .light, .accessibility3, 390),
|
|
("long-option", .light, .large, 320),
|
|
] {
|
|
let source = name == "long-option"
|
|
? #"{"questions":[{"id":"skill","header":"部署与数据存储方案","question":"原型应该采用哪种 **部署方案**？请考虑后续维护成本。","options":[{"label":"使用本地 SQLite 数据库并将应用部署到自有服务器 (Recommended)","description":"保留完整数据控制权，使用 `sqlite` 文件进行备份。"},{"label":"使用托管数据库与云平台","description":"减少服务器维护，但需要管理额外成本。"}]}]}"#
|
|
: Self.input
|
|
let driver = Driver(tool: try makeTool(source))
|
|
let (window, host) = try host(Specimen(driver: driver, theme: theme, typeSize: size), width: width)
|
|
defer { window.isHidden = true }
|
|
try await settle { driver.height > 100 }
|
|
XCTAssertTrue(driver.draft.selections.isEmpty)
|
|
let initial = driver.height
|
|
if size == .large { XCTAssertLessThan(initial, 720, "The default card must not require a second viewport") }
|
|
try capture(window, name: name)
|
|
if size.isAccessibilitySize, let scroll = findScroll(host.view) {
|
|
let bottom = max(-scroll.adjustedContentInset.top,
|
|
scroll.contentSize.height - scroll.bounds.height + scroll.adjustedContentInset.bottom)
|
|
scroll.setContentOffset(CGPoint(x: 0, y: bottom), animated: false)
|
|
try await Task.sleep(for: .milliseconds(150))
|
|
try capture(window, name: "large-type-bottom")
|
|
scroll.setContentOffset(CGPoint(x: 0, y: -scroll.adjustedContentInset.top), animated: false)
|
|
}
|
|
let form = QuestionAnswerForm(tool: driver.tool)
|
|
driver.draft.select(0, at: 0, in: form)
|
|
if name == "light" {
|
|
try await Task.sleep(for: .milliseconds(150))
|
|
try capture(window, name: "selected")
|
|
}
|
|
driver.draft.toggleText(at: 0, in: form)
|
|
driver.draft.setText("希望先学好英语。\nKeep my selection and this note.", at: 0, in: form)
|
|
try await settle { driver.height > initial + 30 }
|
|
let edited = driver.draft
|
|
driver.tool.description = "An SSE update unrelated to the answers"
|
|
try await Task.sleep(for: .milliseconds(100))
|
|
XCTAssertEqual(driver.draft, edited)
|
|
// Local selections are not a recorded answer or a successful POST.
|
|
XCTAssertFalse(questionToolDetails(driver.tool).hasAnswers)
|
|
XCTAssertNil(host.presentedViewController, "Answering stays in the conversation")
|
|
if name == "light" { try capture(window, name: "light-note") }
|
|
driver.tool.permission = ToolPermission(id: "reply", status: .resolved)
|
|
driver.tool.state = .completed
|
|
let chosen = try XCTUnwrap(form.fields.first?.options.first?.label)
|
|
driver.tool.result = .object(["answers": .object(["skill": .object([
|
|
"answers": .array([.string(chosen)]),
|
|
])])])
|
|
try await settle { driver.height < initial }
|
|
XCTAssertEqual(questionAnswerSummary(questionToolDetails(driver.tool).questions[0]), QuestionOptionTitle(chosen).text)
|
|
if name == "light" { try capture(window, name: "answered") }
|
|
}
|
|
}
|
|
|
|
private struct Row: Identifiable, Equatable {
|
|
let index: Int
|
|
var id: String { String(index) }
|
|
}
|
|
|
|
private struct Transcript: View {
|
|
let driver: Driver
|
|
var body: some View {
|
|
AnchoredTranscriptList(
|
|
items: (0..<40).map { Row(index: $0) }, historyVersion: 0, jumpToken: 0,
|
|
historyControlID: "-1", onViewport: { _ in }, onLayout: { _, _ in }
|
|
) { row in
|
|
AnyView(Group {
|
|
if row.index == 10 { Card(driver: driver) }
|
|
else { Text("Message \(row.id)").frame(maxWidth: .infinity).frame(height: 100) }
|
|
})
|
|
}
|
|
.hapiTypography()
|
|
}
|
|
}
|
|
|
|
func testSteppingEditingRecyclingAndCompletionPreserveTranscriptStateAndAnchor() async throws {
|
|
let input = #"{"questions":[{"id":"a","header":"First","question":"Choose one","options":[{"label":"A"},{"label":"B"}]},{"id":"b","header":"Second","question":"Choose multiple","multiple":true,"options":[{"label":"C"},{"label":"D"}]}]}"#
|
|
let driver = Driver(tool: try makeTool(input))
|
|
let (window, host) = try host(Transcript(driver: driver), width: 390)
|
|
defer { window.isHidden = true }
|
|
let collection = try XCTUnwrap(findCollection(host.view))
|
|
try await settle { collection.numberOfItems(inSection: 0) == 40 }
|
|
func browse(_ index: Int) async throws {
|
|
let indexPath = IndexPath(item: index, section: 0)
|
|
collection.delegate?.scrollViewWillBeginDragging?(collection)
|
|
collection.scrollToItem(at: indexPath, at: .top, animated: false)
|
|
try await settle {
|
|
rowIntersectsViewport(index, in: collection)
|
|
&& collection.cellForItem(at: indexPath) != nil
|
|
}
|
|
}
|
|
try await browse(10)
|
|
let offset = try XCTUnwrap(rowOffset(10, in: collection))
|
|
let form = QuestionAnswerForm(tool: driver.tool)
|
|
driver.draft.select(0, at: 0, in: form)
|
|
driver.draft.select(1, at: 1, in: form)
|
|
driver.draft.toggleText(at: 1, in: form)
|
|
driver.draft.setText("A multiline draft\nthat must survive recycling", at: 1, in: form)
|
|
try await Task.sleep(for: .milliseconds(300))
|
|
let offsetAfterEdit = try XCTUnwrap(rowOffset(10, in: collection))
|
|
XCTAssertEqual(offsetAfterEdit, offset, accuracy: 1)
|
|
let draft = driver.draft
|
|
// UIHostingConfiguration may keep SwiftUI roots alive while UIKit
|
|
// removes a cell from the viewport, so onAppear is not a reliable
|
|
// recycling signal. Assert the actual row geometry instead.
|
|
try await browse(32)
|
|
try await settle { !rowIntersectsViewport(10, in: collection) }
|
|
XCTAssertFalse(rowIntersectsViewport(10, in: collection))
|
|
try await browse(10)
|
|
try await settle { rowIntersectsViewport(10, in: collection) }
|
|
XCTAssertTrue(rowIntersectsViewport(10, in: collection))
|
|
XCTAssertEqual(driver.draft, draft)
|
|
XCTAssertEqual(driver.draft.page, 1, "Restoring the selected step must not advance it")
|
|
driver.draft.previous(in: form)
|
|
driver.draft.setText("Retained note", at: 0, in: form)
|
|
let anchorOffset = try XCTUnwrap(rowOffset(10, in: collection))
|
|
let expandedHeight = driver.height
|
|
driver.tool.permission = ToolPermission(id: "reply", status: .approved, answers: .object([
|
|
"a": .object(["answers": .array([.string("A")])]),
|
|
"b": .object(["answers": .array([.string("D")])]),
|
|
]))
|
|
try await settle { driver.height < expandedHeight }
|
|
let anchorOffsetAfterCollapse = try XCTUnwrap(rowOffset(10, in: collection))
|
|
XCTAssertEqual(anchorOffsetAfterCollapse, anchorOffset, accuracy: 1)
|
|
}
|
|
|
|
private func host<V: View>(_ view: V, width: CGFloat) throws -> (UIWindow, UIHostingController<V>) {
|
|
let scene = try XCTUnwrap(UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.first)
|
|
let window = UIWindow(windowScene: scene)
|
|
window.frame = CGRect(x: 0, y: 0, width: width, height: 844)
|
|
let host = UIHostingController(rootView: view)
|
|
window.rootViewController = host
|
|
window.makeKeyAndVisible()
|
|
host.view.layoutIfNeeded()
|
|
return (window, host)
|
|
}
|
|
|
|
private func findCollection(_ view: UIView) -> UICollectionView? {
|
|
if let collection = view as? UICollectionView { return collection }
|
|
return view.subviews.lazy.compactMap(findCollection).first
|
|
}
|
|
|
|
private func findScroll(_ view: UIView) -> UIScrollView? {
|
|
if let scroll = view as? UIScrollView { return scroll }
|
|
return view.subviews.lazy.compactMap(findScroll).first
|
|
}
|
|
|
|
private func rowIntersectsViewport(_ index: Int, in collection: UICollectionView) -> Bool {
|
|
collection.layoutIfNeeded()
|
|
guard let frame = collection.layoutAttributesForItem(at: IndexPath(item: index, section: 0))?.frame else {
|
|
return false
|
|
}
|
|
let top = collection.contentOffset.y + collection.adjustedContentInset.top
|
|
let bottom = collection.contentOffset.y + collection.bounds.height - collection.adjustedContentInset.bottom
|
|
return frame.maxY > top && frame.minY < bottom
|
|
}
|
|
|
|
private func rowOffset(_ index: Int, in collection: UICollectionView) -> CGFloat? {
|
|
collection.layoutIfNeeded()
|
|
guard let frame = collection.layoutAttributesForItem(at: IndexPath(item: index, section: 0))?.frame else {
|
|
return nil
|
|
}
|
|
let top = collection.contentOffset.y + collection.adjustedContentInset.top
|
|
return frame.minY - top
|
|
}
|
|
|
|
private func settle(_ condition: () -> Bool) async throws {
|
|
for _ in 0..<100 {
|
|
try await Task.sleep(for: .milliseconds(30))
|
|
if condition() { try await Task.sleep(for: .milliseconds(150)); return }
|
|
}
|
|
XCTFail("Question layout did not settle")
|
|
}
|
|
|
|
private func capture(_ window: UIWindow, name: String) throws {
|
|
guard let path = ProcessInfo.processInfo.environment["HAPI_QUESTION_CAPTURE"] else { return }
|
|
let directory = URL(fileURLWithPath: path, isDirectory: true)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
let image = UIGraphicsImageRenderer(bounds: window.bounds).image { _ in
|
|
window.drawHierarchy(in: window.bounds, afterScreenUpdates: true)
|
|
}
|
|
try XCTUnwrap(image.pngData()).write(to: directory.appendingPathComponent("question-\(name).png"))
|
|
}
|
|
}
|