Repository Public
1// SP Notes iOS2// File: Tests/NoteFeatureTests.swift3// Description: The per-note features without their views: the assistant state machines with a fake provider, history restore,4// reminders, the export menu, attachments of an open note and the wording helpers of the note screen.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9import SPNotesCore10import Testing11import UIKit12import UniformTypeIdentifiers13@testable import SPNotes1415// MARK: - Fakes and helpers1617/// A provider whose answers are scripted by the test: each request takes the next response of the queue.18final class FakeAssistantProvider: AssistantProvider, @unchecked Sendable {19 enum Response {20 case stream(AsyncThrowingStream<AIEvent, Error>)21 case failure(Error)22 }2324 private let lock = NSLock()25 private var responses: [Response] = []26 private var recorded: [AssistantRequest] = []2728 var requests: [AssistantRequest] { lock.withLock { recorded } }2930 /// Queues a stream and returns its continuation, so the test decides when each event arrives.31 @discardableResult32 func queueStream() -> AsyncThrowingStream<AIEvent, Error>.Continuation {33 let (stream, continuation) = AsyncThrowingStream<AIEvent, Error>.makeStream()34 lock.withLock { responses.append(.stream(stream)) }35 return continuation36 }3738 /// Queues a stream that delivers `events` and ends.39 func queue(events: [AIEvent]) {40 let continuation = queueStream()41 events.forEach { continuation.yield($0) }42 continuation.finish()43 }4445 func queue(failure: Error) { lock.withLock { responses.append(.failure(failure)) } }4647 func events(for request: AssistantRequest) async throws -> AsyncThrowingStream<AIEvent, Error> {48 let response: Response? = lock.withLock {49 recorded.append(request)50 return responses.isEmpty ? nil : responses.removeFirst()51 }52 switch response {53 case .stream(let stream)?: return stream54 case .failure(let error)?: throw error55 case nil: throw APIError.invalidResponse56 }57 }58}5960func aiEvent(_ json: String) -> AIEvent { AIEvent(json: Data(json.utf8))! }61let metaEvent = aiEvent(#"{"type":"meta","model":"claude-haiku","provider":"anthropic","reason":"default","budgetNote":null}"#)62func textEvent(_ delta: String) -> AIEvent { .text(delta) }63let doneEvent = aiEvent(#"{"type":"done","usage":null,"costUsd":0.001,"latencyMs":420}"#)6465/// Waits (bounded) until a condition on main-actor state holds.66@MainActor67func eventually(_ condition: () -> Bool) async -> Bool {68 for _ in 0..<400 {69 if condition() { return true }70 try? await Task.sleep(for: .milliseconds(5))71 }72 return condition()73}7475@MainActor76func makeApp() throws -> AppModel {77 let directory = FileManager.default.temporaryDirectory.appendingPathComponent("spnotes-tests-\(UUID().uuidString)", isDirectory: true)78 return try AppModel(configuration: AppConfiguration(api: .production(appVersion: "tests"), dataDirectory: directory, inMemoryStore: true))79}8081func action(_ request: AssistantRequest?) -> AIActionRequest? { if case .action(let body)? = request { return body } else { return nil } }82func chat(_ request: AssistantRequest?) -> AIChatRequest? { if case .chat(let body)? = request { return body } else { return nil } }8384// MARK: - Assistant: action on a text8586@MainActor87@Suite("Assistant — actions") struct AssistantActionTests {88 func model(_ provider: FakeAssistantProvider, text: String = "Un texte à résumer.", selection: Bool = true, availability: @escaping AssistantAvailability = { nil }) -> AssistantActionModel {89 let model = AssistantActionModel(sourceText: text, hasSelection: selection, provider: provider, availability: availability)90 model.renderInterval = 091 return model92 }9394 @Test func streamsTheAnswerAndFinishes() async {95 let provider = FakeAssistantProvider()96 provider.queue(events: [metaEvent, textEvent("Bon"), textEvent("jour"), doneEvent])97 let model = model(provider)98 #expect(model.phase == .idle)99 model.run(.init(action: .summarize))100 #expect(model.phase == .streaming)101 await model.settle()102 #expect(model.phase == .finished(stopped: false))103 #expect(model.text == "Bonjour")104 #expect(model.renderedText == "Bonjour")105 #expect(model.modelLine == "claude-haiku · anthropic")106 #expect(model.canInsert)107 let sent = action(provider.requests.first)108 #expect(sent?.action == .summarize)109 #expect(sent?.text == "Un texte à résumer.")110 #expect(sent?.confirmExpensive == nil)111 }112113 @Test func aStreamThatEndsWithoutDoneStillFinishes() async {114 let provider = FakeAssistantProvider()115 provider.queue(events: [textEvent("fin")])116 let model = model(provider)117 model.run(.init(action: .rewrite))118 await model.settle()119 #expect(model.phase == .finished(stopped: false))120 #expect(model.text == "fin")121 }122123 @Test func translateAndCustomCarryTheirParameters() async {124 let provider = FakeAssistantProvider()125 provider.queue(events: [doneEvent])126 provider.queue(events: [doneEvent])127 let model = model(provider)128 model.run(.init(action: .translate, language: "en"))129 await model.settle()130 model.run(.init(action: .custom, instruction: "Fais un haïku"))131 await model.settle()132 #expect(action(provider.requests[0])?.language == "en")133 #expect(action(provider.requests[1])?.action == .custom)134 #expect(action(provider.requests[1])?.instruction == "Fais un haïku")135 }136137 @Test func stopKeepsWhatWasReceivedAndIgnoresTheRest() async {138 let provider = FakeAssistantProvider()139 let stream = provider.queueStream()140 let model = model(provider)141 model.run(.init(action: .expand))142 stream.yield(metaEvent)143 stream.yield(textEvent("Début"))144 #expect(await eventually { model.text == "Début" })145 model.stop()146 #expect(model.phase == .finished(stopped: true))147 #expect(model.canInsert)148 stream.yield(textEvent(" suite"))149 stream.finish()150 try? await Task.sleep(for: .milliseconds(40))151 #expect(model.text == "Début")152 #expect(model.phase == .finished(stopped: true))153 }154155 @Test func expensiveRequestAsksBeforeResending() async {156 let provider = FakeAssistantProvider()157 provider.queue(failure: APIError.confirmExpensive(plan: RawJSON(string: #"{"estCostUsd":0.4,"model":"big","expensive":"This will cost about $0.40"}"#), message: "This will cost about $0.40"))158 provider.queue(events: [metaEvent, textEvent("Résultat"), doneEvent])159 let model = model(provider)160 model.run(.init(action: .summarize))161 await model.settle()162 guard case .awaitingConfirmation(let message) = model.phase else { Issue.record("expected a confirmation, got \(model.phase)"); return }163 #expect(message.contains("This will cost about $0.40"))164 #expect(message.contains("big"))165 #expect(model.text.isEmpty)166 #expect(provider.requests.count == 1)167 model.confirmExpensive()168 await model.settle()169 #expect(provider.requests.count == 2)170 #expect(action(provider.requests[1])?.confirmExpensive == true)171 #expect(action(provider.requests[1])?.action == .summarize)172 #expect(model.phase == .finished(stopped: false))173 #expect(model.text == "Résultat")174 }175176 @Test func confirmationEventInsideTheStreamIsHandledToo() async {177 let provider = FakeAssistantProvider()178 provider.queue(events: [aiEvent(#"{"type":"needs_confirmation","reason":"Long context","plan":{"estCostUsd":1.2}}"#)])179 let model = model(provider)180 model.run(.init(action: .outline))181 await model.settle()182 #expect(model.phase == .awaitingConfirmation("Long context"))183 }184185 @Test func errorsAreClassified() async {186 let provider = FakeAssistantProvider()187 let model = model(provider)188189 provider.queue(events: [metaEvent, textEvent("par"), aiEvent(#"{"type":"error","code":"provider_error","retryable":true,"message":"upstream 529"}"#)])190 model.run(.init(action: .fix))191 await model.settle()192 #expect(model.phase == .failed(AssistantFailure(.provider, detail: "upstream 529", retryable: true)))193 #expect(model.text == "par")194 #expect(!model.canInsert)195196 provider.queue(failure: APIError.offline)197 model.run(.init(action: .fix))198 await model.settle()199 #expect(model.phase == .failed(AssistantFailure(.offline)))200201 provider.queue(failure: APIError.http(status: 503, code: "not_configured", message: "AI is not configured", body: Data()))202 model.run(.init(action: .fix))203 await model.settle()204 if case .failed(let failure) = model.phase { #expect(failure.kind == .notConfigured); #expect(!failure.retryable) } else { Issue.record("expected not configured") }205206 provider.queue(failure: APIError.http(status: 401, code: "unauthenticated", message: "Sign in", body: Data()))207 model.run(.init(action: .fix))208 await model.settle()209 if case .failed(let failure) = model.phase { #expect(failure.kind == .sessionExpired) } else { Issue.record("expected session expired") }210 }211212 @Test func nothingIsSentWhenTheAssistantCannotBeReached() async {213 let provider = FakeAssistantProvider()214 let offline = model(provider, availability: { AssistantFailure(.offline) })215 offline.run(.init(action: .summarize))216 #expect(offline.phase == .failed(AssistantFailure(.offline)))217 let empty = model(provider, text: " \n")218 empty.run(.init(action: .summarize))219 #expect(empty.phase == .failed(AssistantFailure(.emptyText)))220 let long = model(provider, text: String(repeating: "a", count: AssistantText.maxActionCharacters + 1))221 long.run(.init(action: .summarize))222 #expect(long.phase == .failed(AssistantFailure(.tooLong)))223 #expect(provider.requests.isEmpty)224 }225226 @Test func regenerateRunsTheSameActionAgain() async {227 let provider = FakeAssistantProvider()228 provider.queue(events: [textEvent("premier"), doneEvent])229 provider.queue(events: [textEvent("second"), doneEvent])230 let model = model(provider)231 model.run(.init(action: .translate, language: "es"))232 await model.settle()233 #expect(model.text == "premier")234 model.regenerate()235 #expect(model.text.isEmpty)236 await model.settle()237 #expect(model.text == "second")238 #expect(provider.requests.count == 2)239 #expect(provider.requests[0] == provider.requests[1])240 model.reset()241 #expect(model.phase == .idle)242 #expect(model.invocation == nil)243 }244245 @Test func catalogueCoversTheBackendActions() {246 let kinds = Set(AssistantCatalog.groups.flatMap(\.actions).map(\.kind))247 let expected: Set<AIActionKind> = [.summarize, .rewrite, .fix, .translate, .simplify, .expand, .shorten, .formal, .outline, .toTasks, .toList, .table, .explain, .continue, .actionItems]248 #expect(kinds == expected)249 #expect(AssistantCatalog.languages.map(\.code) == ["fr", "en", "es", "de", "it", "pt"])250 }251}252253// MARK: - Assistant: questions254255@MainActor256@Suite("Assistant — questions") struct AssistantChatTests {257 @Test func eachSendHasItsOwnClientIdAndKeepsTheConversation() async {258 let provider = FakeAssistantProvider()259 let page = "0b7f6c0e-3f0a-4d5e-9b0a-111111111111"260 provider.queue(events: [261 aiEvent(#"{"type":"meta","model":"m","provider":"openai","conversationId":"c1","sources":[{"n":1,"pageId":"\#(page)","title":"Budget","heading":"Loyer","excerpt":"…"},{"n":2,"pageId":"\#(page)","title":"Budget","heading":null,"excerpt":"…"}]}"#),262 textEvent("Brouillon"),263 aiEvent(#"{"type":"done","messageId":"m1","content":"Réponse finale [1]","usage":null,"costUsd":null,"latencyMs":10,"sources":[{"n":1,"pageId":"\#(page)","title":"Budget","heading":"Loyer","excerpt":"…"}]}"#),264 ])265 provider.queue(events: [textEvent("Deuxième"), doneEvent])266 let model = AssistantChatModel(pageId: page, pageIsOnServer: true, provider: provider)267 model.send(" Combien pour le loyer ? ")268 #expect(model.isStreaming)269 await model.settle()270 #expect(!model.isStreaming)271 #expect(model.messages.count == 2)272 #expect(model.messages[0].role == .user)273 #expect(model.messages[0].text == "Combien pour le loyer ?")274 #expect(model.messages[1].text == "Réponse finale [1]")275 #expect(model.messages[1].state == .done)276 #expect(model.messages[1].sources.map(\.n) == [1])277 #expect(model.messages[1].modelLine == "m · openai")278 #expect(model.conversationId == "c1")279 model.send("Et l’an dernier ?")280 await model.settle()281 let first = chat(provider.requests[0]), second = chat(provider.requests[1])282 #expect(first?.mode == .notes)283 #expect(first?.pageId == nil)284 #expect(first?.conversationId == nil)285 #expect(second?.conversationId == "c1")286 #expect(first?.clientId != second?.clientId)287 #expect(model.clientIds.count == 2)288 for id in model.clientIds { #expect(id.range(of: "^[A-Za-z0-9_-]{8,64}$", options: .regularExpression) != nil) }289 }290291 @Test func pageModesSendThePageAndNeedTheServerCopy() async {292 let provider = FakeAssistantProvider()293 provider.queue(events: [textEvent("Résumé"), doneEvent])294 let synced = AssistantChatModel(pageId: "p1", pageIsOnServer: true, provider: provider)295 synced.mode = .summarise296 synced.send("Résume")297 await synced.settle()298 #expect(chat(provider.requests.first)?.pageId == "p1")299 #expect(chat(provider.requests.first)?.mode == .summarise)300301 let local = AssistantChatModel(pageId: "p2", pageIsOnServer: false, provider: provider)302 local.mode = .actions303 local.send("Quoi faire ?")304 #expect(local.messages.last?.state == .failed(AssistantFailure(.pageNotSynced)))305 #expect(!local.isStreaming)306 #expect(provider.requests.count == 1)307 }308309 @Test func failuresStopAndRetryReplaceTheAnswer() async {310 let provider = FakeAssistantProvider()311 provider.queue(failure: APIError.offline)312 provider.queue(events: [textEvent("Voilà"), doneEvent])313 let model = AssistantChatModel(pageId: nil, pageIsOnServer: false, provider: provider)314 model.mode = .general315 model.send("Bonjour")316 await model.settle()317 #expect(model.messages.last?.state == .failed(AssistantFailure(.offline)))318 model.retry()319 await model.settle()320 #expect(model.messages.count == 2)321 #expect(model.messages.last?.text == "Voilà")322 #expect(model.clientIds.count == 2)323 #expect(Set(model.clientIds).count == 2)324325 let stream = provider.queueStream()326 model.send("Encore")327 stream.yield(textEvent("Dé"))328 #expect(await eventually { model.messages.last?.text == "Dé" })329 model.stop()330 #expect(model.messages.last?.state == .stopped)331 #expect(!model.isStreaming)332 }333334 @Test func expensiveQuestionIsConfirmedThenResent() async {335 let provider = FakeAssistantProvider()336 provider.queue(events: [aiEvent(#"{"type":"needs_confirmation","reason":"Long context","plan":{"expensive":"About $1.20"}}"#)])337 provider.queue(events: [textEvent("Ok"), doneEvent])338 let model = AssistantChatModel(pageId: nil, pageIsOnServer: false, provider: provider)339 model.send("Analyse tout")340 await model.settle()341 #expect(model.messages.last?.state == .awaitingConfirmation("About $1.20"))342 model.confirmExpensive()343 await model.settle()344 #expect(chat(provider.requests[1])?.confirmExpensive == true)345 #expect(chat(provider.requests[1])?.message == "Analyse tout")346 #expect(model.messages.last?.text == "Ok")347 #expect(model.messages.count == 2)348 }349350 @Test func sourcesAreMergedByNote() {351 let sources = [AssistantSource(n: 1, pageId: "a", title: "A"), AssistantSource(n: 2, pageId: "a", title: "A"), AssistantSource(n: 3, pageId: "b", title: "B"), AssistantSource(n: 4, pageId: nil, title: "?")]352 #expect(AssistantSource.uniquePages(sources).map(\.n) == [1, 3])353 }354}355356// MARK: - History357358@MainActor359@Suite("Historique") struct HistoryTests {360 @Test func restoringALocalVersionKeepsTheCurrentTextAsARestorePoint() async throws {361 let app = try makeApp()362 let id = try await app.createNote(title: "Plan", document: NoteDocument(markdown: "Première version"))363 #expect(try await app.store.snapshot(pageId: id, reason: "open") != nil)364 try await app.save(noteId: id, title: "Plan", document: NoteDocument(markdown: "Deuxième version"))365 let versions = try await app.store.localVersions(pageId: id)366 #expect(versions.count == 1)367 let restored = try await app.restoreLocalVersion(versions[0].id)368 #expect(restored.plainText.contains("Première version"))369 let page = try #require(try await app.store.page(id: id))370 #expect(page.plainText.contains("Première version"))371 #expect(page.isDirty)372 let after = try await app.store.localVersions(pageId: id)373 #expect(after.contains { $0.reason == "before-restore" })374 let kept = try #require(after.first { $0.reason == "before-restore" })375 #expect(try await app.store.localVersion(id: kept.id)?.plainText.contains("Deuxième version") == true)376 }377378 @Test func aServerVersionIsAppliedAsALocalSave() async throws {379 let app = try makeApp()380 let id = try await app.createNote(title: "Note", document: NoteDocument(markdown: "Texte local"))381 var server = NoteDocument(markdown: "# Titre\n\nTexte du serveur")382 server.ensureBlockIds()383 let changed = try await app.applyServerVersion(noteId: id, title: "Titre du serveur", content: try server.jsonData())384 #expect(changed)385 let page = try #require(try await app.store.page(id: id))386 #expect(page.title == "Titre du serveur")387 #expect(page.plainText.contains("Texte du serveur"))388 #expect(page.dirtyContent)389 let versions = try await app.store.localVersions(pageId: id)390 let before = try #require(versions.first { $0.reason == "before-restore" })391 #expect(try await app.store.localVersion(id: before.id)?.plainText.contains("Texte local") == true)392 // an unreadable snapshot changes nothing393 await #expect(throws: (any Error).self) { try await app.applyServerVersion(noteId: id, title: "x", content: Data("pas du json".utf8)) }394 #expect(try await app.store.page(id: id)?.title == "Titre du serveur")395 }396397 @Test func serverCopiesOfAConflictAreLabelled() {398 #expect(HistoryLabels.server(reason: "conflict · this device's copy (not applied)", version: -3).contains("non appliquée"))399 #expect(HistoryLabels.isUnappliedCopy(reason: "conflict · this device's copy (not applied)", version: -3))400 #expect(HistoryLabels.server(reason: "conflict · other session's copy", version: 7).contains("autre session"))401 #expect(!HistoryLabels.isUnappliedCopy(reason: "conflict · other session's copy", version: 7))402 #expect(HistoryLabels.server(reason: nil, version: 4) == "Version 4")403 #expect(HistoryLabels.local(reason: "before-restore") == "Avant une restauration")404 #expect(HistoryLabels.local(reason: "autre") == "autre")405 }406}407408// MARK: - Reminders409410@MainActor411@Suite("Rappels") struct ReminderTests {412 @Test func defaultDateIsTheNextFullHourAtLeastHalfAnHourAway() {413 var calendar = Calendar(identifier: .gregorian)414 calendar.timeZone = TimeZone(identifier: "America/Toronto")!415 let now = calendar.date(from: DateComponents(year: 2026, month: 11, day: 18, hour: 14, minute: 40))!416 let proposed = ReminderLogic.defaultDate(from: now, calendar: calendar)417 #expect(calendar.dateComponents([.hour, .minute], from: proposed) == DateComponents(hour: 16, minute: 0))418 let early = calendar.date(from: DateComponents(year: 2026, month: 11, day: 18, hour: 14, minute: 10))!419 #expect(calendar.component(.hour, from: ReminderLogic.defaultDate(from: early, calendar: calendar)) == 15)420 #expect(ReminderLogic.isValid(dueAt: now.addingTimeInterval(120), now: now))421 #expect(!ReminderLogic.isValid(dueAt: now.addingTimeInterval(-3600), now: now))422 #expect(ReminderLogic.cleanLabel(" Appeler\nMarie ") == "Appeler Marie")423 #expect(ReminderLogic.cleanLabel(String(repeating: "x", count: 500)).count == ReminderLogic.maxLabelLength)424 }425426 @Test func aReminderIsSavedEvenWhenNotificationsAreRefused() async throws {427 let app = try makeApp()428 let id = try await app.createNote(title: "Courses", document: NoteDocument(markdown: "Lait"))429 let due = Date().addingTimeInterval(3600)430 let result = try await app.addReminder(noteId: id, noteTitle: "Courses", label: " Passer à l’épicerie ", dueAt: due, permission: { false })431 #expect(!result.notifies)432 #expect(result.reminder.title == "Passer à l’épicerie")433 #expect(result.reminder.pageId == id)434 #expect(result.reminder.dirty)435 var stored = try await app.store.reminders(pageId: id)436 #expect(stored.count == 1)437 #expect(abs((stored[0].dueAt ?? .distantPast).timeIntervalSince(due)) < 1)438439 let done = try await app.setReminderDone(result.reminder.id, done: true, noteTitle: "Courses", notifies: false)440 #expect(done.done)441 #expect(ReminderLogic.sections(try await app.store.reminders(pageId: id)).done.count == 1)442 let reopened = try await app.setReminderDone(result.reminder.id, done: false, noteTitle: "Courses", notifies: false)443 #expect(!reopened.done)444445 try await app.removeReminder(result.reminder.id)446 stored = try await app.store.reminders(pageId: id)447 #expect(ReminderLogic.sections(stored).isEmpty)448 }449450 @Test func remindersAreSplitAroundNow() async throws {451 let app = try makeApp()452 let id = try await app.createNote(title: "N")453 let now = Date()454 let late = try await app.store.createReminder(pageId: id, title: "retard", dueAt: now.addingTimeInterval(-600))455 let soon = try await app.store.createReminder(pageId: id, title: "bientôt", dueAt: now.addingTimeInterval(600))456 let later = try await app.store.createReminder(pageId: id, title: "plus tard", dueAt: now.addingTimeInterval(6000))457 let finished = try await app.store.createReminder(pageId: id, title: "fait", dueAt: now.addingTimeInterval(-60), done: true)458 let sections = ReminderLogic.sections([later, finished, soon, late], now: now)459 #expect(sections.overdue.map(\.id) == [late.id])460 #expect(sections.upcoming.map(\.id) == [soon.id, later.id])461 #expect(sections.done.map(\.id) == [finished.id])462 #expect(ReminderLogic.title(soon, noteTitle: "N") == "bientôt")463 var unnamed = soon; unnamed.title = ""464 #expect(ReminderLogic.title(unnamed, noteTitle: "Untitled") == "Sans titre")465 }466}467468// MARK: - Export menu469470@MainActor471@Suite("Menu Exporter") struct ExportMenuTests {472 @Test func theMenuOffersTheFiveFormatsInOrder() {473 #expect(NoteExportMenu.formats == [.markdown, .plainText, .pdf, .rtf, .html])474 #expect(NoteExportMenu.formats.map(NoteExportMenu.identifier) == ["export-markdown", "export-plainText", "export-pdf", "export-rtf", "export-html"])475 #expect(Set(NoteExportMenu.formats) == Set(ExportFormat.allCases))476 }477478 @Test func everyFormatWritesAFileNamedAfterTheNote() async throws {479 let app = try makeApp()480 let document = NoteDocument(markdown: "# Recette\n\nUn **gâteau** simple.\n\n- farine\n- sucre")481 for format in NoteExportMenu.formats {482 let url = try NoteExportMenu.export(document: document, title: "Gâteau du dimanche", format: format, app: app)483 #expect(url.pathExtension == format.fileExtension)484 #expect(url.deletingPathExtension().lastPathComponent == "Gâteau du dimanche")485 let size = (try FileManager.default.attributesOfItem(atPath: url.path)[.size] as? Int) ?? 0486 #expect(size > 0, "empty export for \(format)")487 }488 let markdown = try String(contentsOf: NoteExportMenu.export(document: document, title: "Gâteau", format: .markdown, app: app), encoding: .utf8)489 #expect(markdown.contains("**gâteau**"))490 let untitled = try NoteExportMenu.export(document: document, title: " ", format: .plainText, app: app)491 #expect(untitled.lastPathComponent == "Sans titre.txt")492 }493494 @Test func theOpenNoteIsExportedWithItsUnsavedText() async throws {495 let app = try makeApp()496 let id = try await app.createNote(title: "Brouillon", document: NoteDocument(markdown: "Début"))497 let model = NoteEditorModel(noteId: id, app: app)498 model.controller.textView.frame = CGRect(x: 0, y: 0, width: 390, height: 800)499 await model.load()500 model.controller.textView.selectedRange = NSRange(location: 5, length: 0)501 model.controller.insertText(" et suite")502 let text = try String(contentsOf: NoteExportMenu.export(model: model, format: .plainText), encoding: .utf8)503 #expect(text.contains("Début et suite"))504 }505}506507// MARK: - The open note: helpers of the screen508509@MainActor510@Suite("Écran de note") struct NoteScreenTests {511 func openNote(_ app: AppModel, markdown: String = "Bonjour") async throws -> NoteEditorModel {512 let id = try await app.createNote(title: "Note", document: NoteDocument(markdown: markdown))513 let model = NoteEditorModel(noteId: id, app: app)514 model.controller.textView.frame = CGRect(x: 0, y: 0, width: 390, height: 800)515 await model.load()516 return model517 }518519 @Test func saveNowWritesTheTextBeforeReadingTheStore() async throws {520 let app = try makeApp()521 let model = try await openNote(app)522 model.controller.textView.selectedRange = NSRange(location: 7, length: 0)523 model.controller.insertText(" à tous")524 model.title = "Salut"525 model.titleChanged()526 await model.saveNow()527 let page = try #require(try await app.store.page(id: model.noteId))528 #expect(page.title == "Salut")529 #expect(page.plainText.contains("Bonjour à tous"))530 }531532 @Test func deletingAnAttachmentRemovesItsBlock() async throws {533 let app = try makeApp()534 let model = try await openNote(app)535 let png = UIGraphicsImageRenderer(size: CGSize(width: 8, height: 8)).pngData { $0.fill(CGRect(x: 0, y: 0, width: 8, height: 8)) }536 let image = try await app.attach(data: png, filename: "photo.png", mime: "image/png", to: model.noteId)537 let file = try await app.attach(data: Data("a,b".utf8), filename: "table.csv", mime: "text/csv", to: model.noteId)538 model.controller.insertBlockAtom(image)539 model.controller.insertBlockAtom(file)540 let records = try await app.store.attachments(pageId: model.noteId)541 let imageRecord = try #require(records.first { $0.filename == "photo.png" })542 let fileRecord = try #require(records.first { $0.filename == "table.csv" })543 #expect(model.atomRanges(forAttachment: imageRecord.id).count == 1)544 #expect(model.atomRanges(forAttachment: fileRecord.id).count == 1)545 #expect(model.removeAtoms(forAttachment: imageRecord.id) == 1)546 #expect(model.atomRanges(forAttachment: imageRecord.id).isEmpty)547 #expect(model.atomRanges(forAttachment: fileRecord.id).count == 1)548 #expect(model.controller.document().lines.contains { $0.type == "fileBlock" })549 #expect(!model.controller.document().lines.contains { $0.type == "image" })550 #expect(model.removeAtoms(forAttachment: "inconnu") == 0)551552 #expect(AttachmentPresentation.status(imageRecord).text == "En attente d’envoi")553 #expect(AttachmentPresentation.isOnDevice(imageRecord))554 #expect(AttachmentPresentation.symbol(mime: "image/png", filename: "photo.png") == "photo")555 #expect(AttachmentPresentation.symbol(mime: "application/octet-stream", filename: "a.zip") == "doc.zipper")556 }557558 @Test func drawingSourcesAreHiddenAndFollowTheirPicture() async throws {559 let app = try makeApp()560 let model = try await openNote(app)561 let png = UIGraphicsImageRenderer(size: CGSize(width: 8, height: 8)).pngData { $0.fill(CGRect(x: 0, y: 0, width: 8, height: 8)) }562 await model.insertDrawing(png: png, source: Data([1, 2, 3]), replacing: nil)563 let records = try await app.store.attachments(pageId: model.noteId)564 #expect(records.count == 2)565 let picture = try #require(records.first { $0.filename.hasSuffix(".png") })566 let source = try #require(records.first { $0.filename.hasSuffix(".pkdrawing") })567 #expect(AttachmentPresentation.isDrawingSource(source))568 #expect(!AttachmentPresentation.isDrawingSource(picture))569 #expect(AttachmentPresentation.drawingCompanion(of: picture, in: records)?.id == source.id)570 #expect(AttachmentPresentation.drawingCompanion(of: source, in: records) == nil)571 }572573 @Test func recognisedTextGoesBelowTheCaretParagraph() async throws {574 let app = try makeApp()575 let model = try await openNote(app, markdown: "Un\n\nDeux")576 model.controller.textView.selectedRange = NSRange(location: 1, length: 0)577 model.insertRecognizedText("ligne A\n\nligne B\r\n")578 #expect(model.controller.document().plainText().split(separator: "\n").map(String.init) == ["Un", "ligne A", "ligne B", "Deux"])579 }580581 @Test func readOnlyBlocksTyping() async throws {582 let app = try makeApp()583 let model = try await openNote(app)584 model.setReadOnly(true)585 #expect(!model.controller.textView.isEditable)586 model.setReadOnly(false)587 #expect(model.controller.textView.isEditable)588 }589590 @Test func badgeSaysWhereTheTextIs() {591 func badge(_ save: NoteEditorModel.SaveState, _ sync: SyncState?, session: SessionState = .signedIn, online: Bool = true) -> NoteSyncBadge {592 NoteSyncBadge.make(save: save, sync: sync, session: session, isOnline: online)593 }594 #expect(badge(.saved, .synced).symbol == "checkmark.icloud")595 #expect(badge(.saved, .synced).text == "Enregistré")596 #expect(badge(.saved, .pending).symbol == "arrow.triangle.2.circlepath.icloud")597 #expect(badge(.saved, .pending, online: false).text == "Hors ligne")598 #expect(badge(.saved, .pending, session: .expired).text == "Sur l’appareil")599 #expect(badge(.saved, .conflict).tone == .problem)600 #expect(badge(.saved, .error).symbol == "xmark.icloud")601 #expect(badge(.editing, .synced).text == "Enregistrement…")602 #expect(badge(.failed("disque plein"), .synced).detail.contains("disque plein"))603 // never claims "synchronisé" while something is pending604 #expect(!badge(.saved, .pending).detail.contains("et synchronisé"))605 }606607 @Test func statisticsCountTheText() {608 let stats = NoteStatistics(document: NoteDocument(markdown: "# Titre\n\nUn deux trois.\n\n- quatre"))609 #expect(stats.words == 5)610 #expect(stats.paragraphs == 3)611 #expect(stats.charactersWithoutSpaces < stats.characters)612 #expect(stats.readingMinutes == 1)613 #expect(NoteStatistics(document: NoteDocument()).readingMinutes == 0)614 }615616 @Test func droppedItemsAreFilesOrText() {617 #expect(EditorDropHandler.isFile(types: [.jpeg]))618 #expect(EditorDropHandler.isFile(types: [.pdf, .fileURL]))619 #expect(EditorDropHandler.isFile(types: [.zip]))620 #expect(EditorDropHandler.isFile(types: [UTType("com.microsoft.word.doc") ?? .data]))621 #expect(!EditorDropHandler.isFile(types: [.plainText, .utf8PlainText]))622 #expect(!EditorDropHandler.isFile(types: [.url, .plainText]))623 #expect(EditorDropHandler.preferredType(in: [.fileURL, .png]) == .png)624 #expect(EditorDropHandler.preferredType(in: [.pdf]) == .pdf)625 }626627 @Test func conflictFailuresAreExplained() {628 let conflict = APIError.conflict(server: PageConflict(version: 3, title: "T", content: .emptyObject, properties: .emptyObject, updatedAt: Date()), message: "changed")629 #expect(ConflictMessages.failure(conflict, isOnline: true, session: .signedIn).contains("encore changé"))630 #expect(ConflictMessages.failure(APIError.offline, isOnline: false, session: .signedIn) == ConflictMessages.offline)631 #expect(ConflictMessages.failure(APIError.timeout, isOnline: true, session: .expired).contains("Connecte-toi"))632 }633}634