SPB Git

Repository Public

NoteFeatureTests.swift 32.5 KB 634 lines swift

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
Files main
Menu

Theme