mirror of
https://github.com/wu736139669/hapi.git
synced 2026-11-16 03:16:29 +00:00
327 lines
17 KiB
Swift
327 lines
17 KiB
Swift
import HapiClient
|
|
import HapiProtocol
|
|
import HapiUI
|
|
import Observation
|
|
import SwiftUI
|
|
import UIKit
|
|
import UniformTypeIdentifiers
|
|
import XCTest
|
|
@testable import Hapi
|
|
|
|
/// App-hosted platform coverage. The optional interactive test uses the real
|
|
/// composer and system pickers; HAPI_ATTACHMENT_TEST_URL opts into a disposable
|
|
/// loopback upload fixture, never a saved hub or the user's Keychain.
|
|
@MainActor
|
|
final class AttachmentUploadPresentationTests: XCTestCase {
|
|
private actor FixtureHTTP: HTTPPerforming {
|
|
var attempts = 0
|
|
private var resumed: Set<String> = []
|
|
private var resumeWaiter: CheckedContinuation<Void, Never>?
|
|
private let gateResume: Bool
|
|
private let target: String?
|
|
private let resumeStatus: Int
|
|
private(set) var resumeStarted = false
|
|
private(set) var uploadSessions: [String] = []
|
|
|
|
init(gateResume: Bool = false, target: String? = nil, resumeStatus: Int = 200) {
|
|
self.gateResume = gateResume
|
|
self.target = target
|
|
self.resumeStatus = resumeStatus
|
|
}
|
|
|
|
func openResumeGate() { resumeWaiter?.resume(); resumeWaiter = nil }
|
|
|
|
func perform(_ request: URLRequest) async throws -> (Data, HTTPURLResponse) {
|
|
let path = request.url!.path
|
|
let id = path.split(separator: "/").dropFirst(2).first.map(String.init) ?? ""
|
|
if path.hasSuffix("/upload") { attempts += 1; uploadSessions.append(id) }
|
|
let status: Int
|
|
let body: String
|
|
if path.hasSuffix("/resume") {
|
|
resumeStarted = true
|
|
if gateResume { await withCheckedContinuation { resumeWaiter = $0 } }
|
|
status = resumeStatus
|
|
resumed.insert(id)
|
|
body = status == 200 ? "{\"sessionId\":\"\(target ?? id)\"}" : #"{"error":"Machine offline"}"#
|
|
} else if path.hasSuffix("/upload"), id.hasSuffix("-inactive"), !resumed.contains(id) {
|
|
status = 409
|
|
body = #"{"error":"Session is inactive","code":"session_inactive"}"#
|
|
} else if path.contains("-retry/"), attempts == 1 {
|
|
status = 500
|
|
body = #"{"success":false,"error":"Fixture upload failure — retry should succeed"}"#
|
|
} else {
|
|
status = 200
|
|
body = path == "/api/sessions" ? #"{"sessions":[]}"# : path.hasSuffix("/upload")
|
|
? #"{"success":true,"path":"/fixture/uploaded"}"#
|
|
: #"{"success":true}"#
|
|
}
|
|
return (Data(body.utf8), HTTPURLResponse(url: request.url!, statusCode: status,
|
|
httpVersion: nil, headerFields: ["Content-Type": "application/json"])!)
|
|
}
|
|
}
|
|
|
|
private func interactor(suffix: String) throws -> ChatInteractor {
|
|
let fixtureURL = ProcessInfo.processInfo.environment["HAPI_ATTACHMENT_TEST_URL"]
|
|
let url = try XCTUnwrap(URL(string: fixtureURL ?? "https://attachment-fixture.invalid"))
|
|
let performer: any HTTPPerforming = fixtureURL == nil ? FixtureHTTP() : URLSessionHTTPPerformer.shared
|
|
let credentials = InMemoryCredentialStore()
|
|
let payload = Data(#"{"uid":1,"exp":4102444800,"ns":"attachment-fixture"}"#.utf8).base64EncodedString()
|
|
try credentials.store(HubCredentials(hubUrl: url.absoluteString, accessToken: "fixture-only",
|
|
jwt: "e30.\(payload).fixture"))
|
|
let auth = AuthManager(baseURL: url, credentialStore: credentials, performer: performer)
|
|
let api = APIClient(baseURL: url, authManager: auth, performer: performer)
|
|
return ChatInteractor(sessionId: "attachment-\(UUID().uuidString)-\(suffix)", api: api,
|
|
sessionStore: SessionListStore(api: api), windows: MessageWindowControllers(provider: api))
|
|
}
|
|
|
|
private func wait(_ condition: () -> Bool) async throws {
|
|
for _ in 0..<500 {
|
|
if condition() { return }
|
|
try await Task.sleep(for: .milliseconds(20))
|
|
}
|
|
XCTFail("Timed out waiting for upload")
|
|
}
|
|
|
|
func testFilePreparationAndCameraDelegateJPEGUpload() async throws {
|
|
let interactor = try interactor(suffix: "success")
|
|
let file = FileManager.default.temporaryDirectory.appendingPathComponent("probe-\(UUID().uuidString).txt")
|
|
let content = Data("HAPI simulator attachment probe\n".utf8)
|
|
try content.write(to: file)
|
|
defer { try? FileManager.default.removeItem(at: file) }
|
|
guard case .ready(let preparedFile) = await AttachmentPreparer.prepare(fileURL: file) else {
|
|
return XCTFail("File preparation failed")
|
|
}
|
|
XCTAssertEqual(preparedFile.bytes, content)
|
|
interactor.attachments.add(preparedFile)
|
|
|
|
var captured: Data?
|
|
var dismissed = false
|
|
let coordinator = CameraCaptureView.Coordinator(onCapture: { captured = $0 }, dismiss: { dismissed = true })
|
|
let image = UIGraphicsImageRenderer(size: CGSize(width: 32, height: 32)).image { context in
|
|
UIColor.orange.setFill()
|
|
context.fill(CGRect(x: 0, y: 0, width: 32, height: 32))
|
|
}
|
|
coordinator.imagePickerController(UIImagePickerController(), didFinishPickingMediaWithInfo: [.originalImage: image])
|
|
XCTAssertTrue(dismissed)
|
|
let jpeg = try XCTUnwrap(captured)
|
|
guard case .ready(let preparedPhoto) = await AttachmentPreparer.prepare(data: jpeg,
|
|
filename: AttachmentPreparer.cameraFilename(), mimeType: "image/jpeg") else {
|
|
return XCTFail("Camera JPEG preparation failed")
|
|
}
|
|
XCTAssertNotNil(preparedPhoto.previewBytes)
|
|
interactor.attachments.add(preparedPhoto)
|
|
try await wait { !interactor.attachments.hasUnsettled }
|
|
XCTAssertEqual(interactor.attachments.items.count, 2)
|
|
XCTAssertTrue(interactor.attachments.allReady)
|
|
}
|
|
|
|
func testUploadFailureKeepsReasonAndRetrySucceeds() async throws {
|
|
let interactor = try interactor(suffix: "retry")
|
|
interactor.attachments.add(PreparedAttachment(filename: "retry-probe.txt", mimeType: "text/plain", bytes: Data("probe".utf8)))
|
|
try await wait { interactor.attachments.items.first?.status == .failed }
|
|
XCTAssertEqual(interactor.attachments.items.first?.errorMessage, "HTTP 500 (Fixture upload failure — retry should succeed)")
|
|
let id = try XCTUnwrap(interactor.attachments.items.first?.id)
|
|
interactor.attachments.retry(id)
|
|
XCTAssertNil(interactor.attachments.items.first?.errorMessage)
|
|
try await wait { interactor.attachments.allReady }
|
|
}
|
|
|
|
func testInactiveSessionResumesAndUploadsWithoutPermissionChanges() async throws {
|
|
let interactor = try interactor(suffix: "inactive")
|
|
interactor.attachments.add(PreparedAttachment(filename: "inactive-probe.txt", mimeType: "text/plain", bytes: Data("probe".utf8)))
|
|
try await wait { interactor.attachments.allReady }
|
|
XCTAssertNil(interactor.attachments.items.first?.errorMessage)
|
|
}
|
|
|
|
private func recoveryHub(performer: FixtureHTTP) throws -> HubSession {
|
|
let url = "https://attachment-\(UUID().uuidString.lowercased()).invalid"
|
|
let credentials = InMemoryCredentialStore()
|
|
let payload = Data(#"{"uid":1,"exp":4102444800,"ns":"attachment-fixture"}"#.utf8).base64EncodedString()
|
|
try credentials.store(HubCredentials(hubUrl: url, accessToken: "fixture-only", jwt: "e30.\(payload).fixture"))
|
|
return try XCTUnwrap(HubSession(hubUrl: url, credentialStore: credentials, performer: performer))
|
|
}
|
|
|
|
private func waitForResume(_ performer: FixtureHTTP) async throws {
|
|
for _ in 0..<500 {
|
|
if await performer.resumeStarted { return }
|
|
try await Task.sleep(for: .milliseconds(20))
|
|
}
|
|
XCTFail("Timed out waiting for resume")
|
|
}
|
|
|
|
func testReplacementSessionKeepsComposerAndDefersMergedSourceRemoval() async throws {
|
|
let performer = FixtureHTTP(gateResume: true, target: "replacement")
|
|
let hub = try recoveryHub(performer: performer)
|
|
defer { hub.shutdown() }
|
|
let original = hub.makeChatInteractor(sessionId: "source-inactive")
|
|
original.setComposerText("Keep my draft")
|
|
var target: String?
|
|
original.onEvent = { if case .sessionSuperseded(let id) = $0 { target = id } }
|
|
original.attachments.add(PreparedAttachment(filename: "probe.txt", mimeType: "text/plain", bytes: Data("probe".utf8)))
|
|
try await waitForResume(performer)
|
|
// The Hub can publish this SSE event before /resume returns.
|
|
hub.sessionStore.onSessionRemoved?(original.sessionId)
|
|
XCTAssertNil(hub.sessionRemoval)
|
|
original.setComposerText("Keep my latest typing")
|
|
await performer.openResumeGate()
|
|
try await wait { target == "replacement" && original.attachments.allReady }
|
|
// Also tolerate source removal arriving after the HTTP response but
|
|
// before SwiftUI has constructed the replacement screen.
|
|
hub.sessionStore.onSessionRemoved?(original.sessionId)
|
|
XCTAssertNil(hub.sessionRemoval)
|
|
original.setComposerText("Typing while navigation is pending")
|
|
let replacement = hub.makeChatInteractor(sessionId: try XCTUnwrap(target))
|
|
XCTAssertTrue(replacement.attachments === original.attachments)
|
|
XCTAssertEqual(replacement.composerText, "Typing while navigation is pending")
|
|
XCTAssertEqual(replacement.attachments.items.count, 1)
|
|
let uploadSessions = await performer.uploadSessions
|
|
XCTAssertEqual(uploadSessions, ["source-inactive", "replacement"])
|
|
replacement.sendMessage()
|
|
try await wait { !replacement.isSending }
|
|
try await Task.sleep(for: .milliseconds(400))
|
|
// The source's pending debounce must not restore the sent draft.
|
|
XCTAssertNil(UserDefaultsChatDrafts(scope: hub.hubUrl).load(sessionId: "replacement"))
|
|
}
|
|
|
|
func testFailedResumeReleasesDeferredRemoval() async throws {
|
|
let performer = FixtureHTTP(gateResume: true, resumeStatus: 503)
|
|
let hub = try recoveryHub(performer: performer)
|
|
defer { hub.shutdown() }
|
|
let original = hub.makeChatInteractor(sessionId: "source-inactive")
|
|
original.attachments.add(PreparedAttachment(filename: "probe.txt", mimeType: "text/plain", bytes: Data("probe".utf8)))
|
|
try await waitForResume(performer)
|
|
hub.sessionStore.onSessionRemoved?(original.sessionId)
|
|
XCTAssertNil(hub.sessionRemoval)
|
|
await performer.openResumeGate()
|
|
try await wait { original.attachments.items.first?.status == .failed }
|
|
XCTAssertEqual(hub.sessionRemoval?.sessionId, original.sessionId)
|
|
XCTAssertEqual(original.attachments.items.first?.errorMessage, "HTTP 503 (Machine offline)")
|
|
}
|
|
|
|
@Observable fileprivate final class Driver {
|
|
let interactor: ChatInteractor
|
|
var notice = "Choose a photo and a text file using +."
|
|
var finished = false
|
|
init(interactor: ChatInteractor) { self.interactor = interactor }
|
|
}
|
|
|
|
private struct ProbeDocument: FileDocument {
|
|
static var readableContentTypes: [UTType] { [.plainText] }
|
|
init() {}
|
|
init(configuration: ReadConfiguration) throws {}
|
|
func fileWrapper(configuration: WriteConfiguration) throws -> FileWrapper {
|
|
FileWrapper(regularFileWithContents: Data("HAPI simulator file-picker probe\n".utf8))
|
|
}
|
|
}
|
|
|
|
private struct PickerHarness: View {
|
|
let driver: Driver
|
|
@State private var exporting = false
|
|
var body: some View {
|
|
NavigationStack {
|
|
VStack(spacing: 16) {
|
|
Text("Disposable upload fixture — no live conversation")
|
|
Text(driver.notice)
|
|
Button("Create test file in Files") { exporting = true }
|
|
Text("Tap + to check available attachment sources.")
|
|
Button("Finish verification") { driver.finished = true }
|
|
Spacer()
|
|
}
|
|
.padding()
|
|
.safeAreaInset(edge: .bottom, spacing: 0) {
|
|
ChatComposerView(interactor: driver.interactor)
|
|
}
|
|
.navigationTitle("Attachment verification")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.fileExporter(isPresented: $exporting, document: ProbeDocument(), contentType: .plainText,
|
|
defaultFilename: "attachment-probe") { _ in }
|
|
}
|
|
.hapiTypography()
|
|
}
|
|
}
|
|
|
|
private func capture(_ window: UIWindow, name: String) throws {
|
|
let image = UIGraphicsImageRenderer(bounds: window.bounds).image { _ in
|
|
window.drawHierarchy(in: window.bounds, afterScreenUpdates: true)
|
|
}
|
|
let url = FileManager.default.temporaryDirectory.appendingPathComponent("\(name).png")
|
|
try XCTUnwrap(image.pngData()).write(to: url)
|
|
let attachment = XCTAttachment(image: image)
|
|
attachment.lifetime = .keepAlways
|
|
attachment.name = name
|
|
add(attachment)
|
|
print("ATTACHMENT_CAPTURE=\(url.path)")
|
|
}
|
|
|
|
func testInteractiveFailureDetailsAndAvailableCamera() async throws {
|
|
let env = ProcessInfo.processInfo.environment
|
|
try XCTSkipUnless(env["HAPI_ATTACHMENT_TEST_URL"] != nil && env["HAPI_ATTACHMENT_INTERACTIVE"] == "1",
|
|
"Opt-in manual error-details and camera presentation check")
|
|
let driver = Driver(interactor: try interactor(suffix: "retry"))
|
|
driver.notice = "Open the failed attachment's Details, retry, and check Camera using +. Then finish."
|
|
driver.interactor.attachments.add(PreparedAttachment(filename: "retry-details.txt", mimeType: "text/plain", bytes: Data("probe".utf8)))
|
|
try await wait { driver.interactor.attachments.items.first?.status == .failed }
|
|
let scene = try XCTUnwrap(UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.first)
|
|
let window = UIWindow(windowScene: scene)
|
|
let host = UIHostingController(rootView: PickerHarness(driver: driver))
|
|
window.rootViewController = host
|
|
window.makeKeyAndVisible()
|
|
defer { window.isHidden = true }
|
|
print("ATTACHMENT_DETAILS_READY cameraAvailable=\(CameraCaptureView.isAvailable)")
|
|
var inspectedFailure = false
|
|
for _ in 0..<4800 {
|
|
if !inspectedFailure, driver.interactor.attachments.items.first?.status == .failed {
|
|
var presented = host.presentedViewController
|
|
while let controller = presented {
|
|
if controller is UIAlertController {
|
|
inspectedFailure = true
|
|
try await Task.sleep(for: .milliseconds(400))
|
|
try capture(window, name: "attachment-failure-details")
|
|
break
|
|
}
|
|
presented = controller.presentedViewController
|
|
}
|
|
}
|
|
if driver.finished {
|
|
XCTAssertTrue(inspectedFailure, "Details must present without triggering a retry")
|
|
XCTAssertTrue(driver.interactor.attachments.allReady)
|
|
try capture(window, name: "attachment-retry-ready")
|
|
return
|
|
}
|
|
try await Task.sleep(for: .milliseconds(100))
|
|
}
|
|
XCTFail("Interactive failure-details check timed out")
|
|
}
|
|
|
|
func testInteractiveSystemPickersOverHTTP() async throws {
|
|
let env = ProcessInfo.processInfo.environment
|
|
try XCTSkipUnless(env["HAPI_ATTACHMENT_TEST_URL"] != nil && env["HAPI_ATTACHMENT_INTERACTIVE"] == "1",
|
|
"Opt-in manual system-picker check against a disposable upload fixture")
|
|
let driver = Driver(interactor: try interactor(suffix: "picker"))
|
|
driver.interactor.onEvent = { [weak driver] in
|
|
if case .notice(let message) = $0 { driver?.notice = message }
|
|
}
|
|
let scene = try XCTUnwrap(UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.first)
|
|
let window = UIWindow(windowScene: scene)
|
|
let host = UIHostingController(rootView: PickerHarness(driver: driver))
|
|
window.rootViewController = host
|
|
window.makeKeyAndVisible()
|
|
defer { window.isHidden = true }
|
|
print("ATTACHMENT_PICKER_READY")
|
|
var previous = ""
|
|
for _ in 0..<4800 {
|
|
let items = driver.interactor.attachments.items
|
|
let summary = items.map { "\($0.filename):\($0.status):\($0.errorMessage ?? "")" }.joined(separator: " | ")
|
|
if summary != previous { print("ATTACHMENT_PICKER_STATE=\(summary)"); previous = summary }
|
|
if items.contains(where: { $0.mimeType.hasPrefix("image/") }),
|
|
items.contains(where: { $0.filename.hasSuffix(".txt") }), driver.interactor.attachments.allReady {
|
|
print("ATTACHMENT_PICKERS_SUCCEEDED")
|
|
try await Task.sleep(for: .seconds(20))
|
|
return
|
|
}
|
|
try await Task.sleep(for: .milliseconds(100))
|
|
}
|
|
XCTFail("Photo and file pickers did not both upload successfully: \(previous)")
|
|
}
|
|
}
|