SPB Git

Repository Public

ShellTests.swift 18.7 KB 357 lines swift

1// SP Notes iOS2// File: Tests/ShellTests.swift3// Description: The pure logic of the navigation shell and organisation screens: list ordering, folder tree and move validity,4//              tag editing, search criteria and date ranges, sync wording, sign-in error mapping, state keys.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9import Testing10import SPNotesCore11@testable import SPNotes1213/// Builds real summaries through an in-memory store (the summary type has no public initialiser).14private func makeStore() throws -> NotesStore { try NotesStore.inMemory() }1516@discardableResult17private func addPage(_ store: NotesStore, _ title: String, parent: String? = nil, section: String? = nil, folder: Bool = false, pinned: Bool = false, tags: [String] = []) async throws -> String {18    let page = try await store.createPage(NewPage(parentId: parent, section: section, title: title, properties: Data((folder ? #"{"folder":true}"# : "{}").utf8), pinned: pinned, preview: "aperçu de \(title)", tags: tags))19    return page.id20}2122@Suite("Ordre des listes")23struct NoteArrangementTests {24    @Test func pinnedNotesComeFirstAndStayUnique() async throws {25        let store = try makeStore()26        let a = try await addPage(store, "Alpha")27        let b = try await addPage(store, "Bravo", pinned: true)28        let c = try await addPage(store, "Charlie")29        let all = try await store.summaries(list: .all)30        let pinned = try await store.summaries(list: .pinned)31        let arranged = NoteArrangement.pinnedFirst(pinned: pinned, rest: all)32        #expect(arranged.first?.id == b)33        #expect(arranged.count == 3)34        #expect(Set(arranged.map(\.id)) == [a, b, c])35    }3637    @Test func titleSortIsNaturalAndPinnedFirstWhenAsked() async throws {38        let store = try makeStore()39        try await addPage(store, "Note 10")40        try await addPage(store, "note 2")41        try await addPage(store, "Zèbre", pinned: true)42        try await addPage(store, "Untitled")43        let all = try await store.summaries(list: .all)44        let plain = NoteArrangement.sorted(all, by: .title, pinnedFirst: false).map(\.title)45        #expect(plain == ["note 2", "Note 10", "Untitled", "Zèbre"])   // « Sans titre » sorts as its displayed title46        let pinnedFirst = NoteArrangement.sorted(all, by: .title, pinnedFirst: true).map(\.title)47        #expect(pinnedFirst.first == "Zèbre")48    }4950    @Test func dateSortIsNewestFirstAndStable() async throws {51        let store = try makeStore()52        let first = try await addPage(store, "Ancienne")53        try await Task.sleep(for: .milliseconds(5))54        let second = try await addPage(store, "Récente")55        let sorted = NoteArrangement.sorted(try await store.summaries(list: .all).reversed(), by: .modified, pinnedFirst: false)56        #expect(sorted.map(\.id) == [second, first])57    }5859    @Test func sourcesKnowWhatTheyOffer() {60        #expect(!NoteArrangement.sortable(.smart(.trash)))61        #expect(!NoteArrangement.sortable(.smart(.inbox)))62        #expect(NoteArrangement.sortable(.smart(.all)))63        #expect(NoteArrangement.sortable(.folder("x")))64        #expect(NoteArrangement.mixesFolders(.tag("a")))65        #expect(!NoteArrangement.mixesFolders(.folder("x")))66        #expect(NoteArrangement.listsFolders(.smart(.trash)))67        #expect(!NoteArrangement.listsFolders(.smart(.all)))68    }6970    @MainActor @Test func listModelPagesAndHidesFoldersInSmartLists() async throws {71        let store = try makeStore()72        try await addPage(store, "Dossier", folder: true)73        for index in 0..<(NoteListModel.pageSize + 15) { try await addPage(store, "Note \(index)") }74        let model = NoteListModel(source: .smart(.all))75        await model.reload(store: store, sort: .modified)76        #expect(model.hasMore)77        #expect(model.notes.count <= NoteListModel.pageSize)78        #expect(!model.notes.contains { $0.isFolder })79        await model.loadMore(store: store)80        #expect(!model.hasMore)81        #expect(model.notes.count == NoteListModel.pageSize + 15)82        await model.reload(store: store, sort: .title)83        #expect(model.notes.count == NoteListModel.pageSize + 15)84        #expect(model.notes.first?.title == "Note 0")85    }8687    @MainActor @Test func folderModelSplitsFoldersAndNotes() async throws {88        let store = try makeStore()89        let root = try await addPage(store, "Projets", section: "projects", folder: true)90        let child = try await addPage(store, "Sous-dossier", parent: root, folder: true)91        try await addPage(store, "Dedans", parent: root)92        try await addPage(store, "Épinglée", parent: root, pinned: true)93        let model = NoteListModel(source: .folder(child))94        await model.reload(store: store, sort: .modified)95        #expect(model.breadcrumb.map(\.id) == [root])96        #expect(model.isEmpty)97        let parent = NoteListModel(source: .folder(root))98        await parent.reload(store: store, sort: .modified)99        #expect(parent.folders.map(\.id) == [child])100        #expect(parent.notes.map(\.title) == ["Épinglée", "Dedans"])101        _ = try await store.trash(id: child)102        await model.reload(store: store, sort: .modified)103        #expect(model.missing)104    }105}106107@Suite("Dossiers et déplacements")108struct FolderTreeTests {109    @Test func treeIsBuiltBySectionWithOrphansAtTheRoot() async throws {110        let store = try makeStore()111        let a = try await addPage(store, "A", folder: true)112        let b = try await addPage(store, "B", parent: a, folder: true)113        let c = try await addPage(store, "C", parent: b, folder: true)114        let plain = try await addPage(store, "Note parent")115        let orphan = try await addPage(store, "Orphelin", parent: plain, folder: true)116        let research = try await addPage(store, "R", section: "research", folder: true)117        let folders = try await store.folderTree()118        let tree = FolderTree.build(folders)119        #expect(tree["notes"]?.map(\.id) == [a, orphan])120        #expect(tree["notes"]?.first?.children.first?.children.first?.id == c)121        #expect(tree["research"]?.map(\.id) == [research])122        #expect(FolderTree.flatten(tree["notes"] ?? []).map(\.depth) == [0, 1, 2, 0])123        #expect(FolderTree.path(of: c, in: folders) == "A › B › C")124    }125126    @Test func aFolderCannotMoveIntoItselfOrItsDescendants() async throws {127        let store = try makeStore()128        let a = try await addPage(store, "A", folder: true)129        let b = try await addPage(store, "B", parent: a, folder: true)130        let c = try await addPage(store, "C", parent: b, folder: true)131        let other = try await addPage(store, "Autre", folder: true)132        let note = try await addPage(store, "Note", parent: a)133        let folders = try await store.folderTree()134        #expect(FolderTree.invalidTargets(moving: [a], folders: folders) == [a, b, c])135        #expect(!MoveRules.isValid(.folder(c), moving: [a], folders: folders))136        #expect(MoveRules.isValid(.folder(other), moving: [a], folders: folders))137        #expect(MoveRules.isValid(.section("projects"), moving: [a], folders: folders))138        #expect(MoveRules.isValid(.folder(c), moving: [note], folders: folders))139        // The rule mirrors the store: what the sheet disables is what the store refuses.140        await #expect(throws: StoreError.cycle) { _ = try await store.move(id: a, parentId: c) }141        let summary = try #require(try await store.summary(id: note))142        #expect(MoveRules.isCurrent(.folder(a), of: summary))143        #expect(!MoveRules.isCurrent(.section("notes"), of: summary))144        #expect(MoveRules.matches("autr", folders: folders).map(\.id) == [other])145        #expect(MoveRules.matches("  ", folders: folders).count == folders.count)146    }147148    @MainActor @Test func folderDeletionTextCountsHonestly() {149        #expect(FolderDeletionText.message(count: 0).contains("vide"))150        #expect(FolderDeletionText.message(count: 3).contains("3"))151    }152}153154@Suite("Tags")155struct TagEditingTests {156    @Test func additionNormalisesLikeTheStore() {157        #expect(TagEditing.adding("  #Projet , URGENT,projet,, ", to: ["idée"]) == ["idée", "projet", "urgent"])158        #expect(TagEditing.adding(String(repeating: "a", count: 60), to: []).first?.count == 40)159        #expect(TagEditing.adding("x", to: (0..<20).map { "t\($0)" }).count == 20)160        #expect(TagEditing.adding("Été 2026", to: []) == NotesStore.normalizeTags(["Été 2026"]))161        #expect(!TagEditing.canAdd(" # ", to: []))162        #expect(!TagEditing.canAdd("Idée", to: ["idée"]))163        #expect(TagEditing.canAdd("neuf", to: ["idée"]))164    }165166    @Test func suggestionsPreferPrefixThenUse() async throws {167        let store = try makeStore()168        try await addPage(store, "1", tags: ["projet", "maison"])169        try await addPage(store, "2", tags: ["projet", "apropos"])170        try await addPage(store, "3", tags: ["pro"])171        let existing = try await store.tags()172        #expect(TagEditing.suggestions(for: "pro", existing: existing, current: []) == ["projet", "pro", "apropos"])173        #expect(TagEditing.suggestions(for: "#PRO", existing: existing, current: ["projet"]) == ["pro", "apropos"])174        #expect(TagEditing.suggestions(for: "", existing: existing, current: []).first == "projet")175        #expect(TagEditing.suggestions(for: "zzz", existing: existing, current: []).isEmpty)176    }177178    @Test func bulkEditingKeepsEachNotesOwnTags() {179        let common = TagEditing.common([["a", "b", "c"], ["b", "a"], ["a", "z", "b"]])180        #expect(common == ["a", "b"])181        #expect(TagEditing.common([]) == [])182        // "b" removed from the common tags, "n" added: the note keeps its own "c".183        #expect(TagEditing.merged(original: ["a", "b", "c"], initialCommon: common, edited: ["a", "n"]) == ["a", "c", "n"])184        #expect(TagEditing.merged(original: ["a", "b"], initialCommon: common, edited: ["a", "b"]) == ["a", "b"])185    }186}187188@Suite("Recherche")189struct SearchCriteriaTests {190    private var calendar: Calendar {191        var calendar = Calendar(identifier: .gregorian)192        calendar.timeZone = TimeZone(identifier: "America/Toronto")!193        return calendar194    }195    private func date(_ year: Int, _ month: Int, _ day: Int, _ hour: Int = 12) -> Date {196        calendar.date(from: DateComponents(year: year, month: month, day: day, hour: hour))!197    }198199    @Test func dateRangesAreWholeDays() {200        let now = date(2026, 11, 18, 15)201        #expect(DateRangeFilter.any.bounds(now: now, calendar: calendar).after == nil)202        #expect(DateRangeFilter.today.bounds(now: now, calendar: calendar).after == date(2026, 11, 18, 0))203        #expect(DateRangeFilter.last7Days.bounds(now: now, calendar: calendar).after == date(2026, 11, 12, 0))204        #expect(DateRangeFilter.last30Days.bounds(now: now, calendar: calendar).after == date(2026, 10, 20, 0))205        #expect(DateRangeFilter.last7Days.bounds(now: now, calendar: calendar).before == nil)206        // A custom range includes its last day entirely, and tolerates reversed bounds.207        let custom = DateRangeFilter.custom(from: date(2026, 11, 10, 18), to: date(2026, 11, 1, 9)).bounds(now: now, calendar: calendar)208        #expect(custom.after == date(2026, 11, 1, 0))209        #expect(custom.before! > date(2026, 11, 10, 23))210        #expect(custom.before! < date(2026, 11, 11, 0))211    }212213    @Test func criteriaTranslateToStoreFilters() {214        var criteria = SearchCriteria()215        #expect(!criteria.isActive)216        criteria.includeArchived = true217        #expect(!criteria.isActive)            // archives alone widen, they do not search218        criteria.tags = ["a", "b"]; criteria.section = "projects"; criteria.folderId = "f"; criteria.favoritesOnly = true; criteria.dateRange = .today219        #expect(criteria.isActive && criteria.hasFilters && !criteria.hasQuery)220        let now = date(2026, 11, 18, 15)221        let filters = criteria.storeFilters(now: now, calendar: calendar)222        #expect(filters == SearchFilters(section: "projects", folderId: "f", tags: ["a", "b"], updatedAfter: date(2026, 11, 18, 0), favoritesOnly: true, includeArchived: true))223        #expect(!filters.includeTrash)224        criteria.clearFilters()225        #expect(criteria == SearchCriteria())226        criteria.query = "   "227        #expect(!criteria.isActive)228    }229230    @Test func filteredListingWithoutTextUsesTheStore() async throws {231        let store = try makeStore()232        let fav = try await addPage(store, "Favorite", tags: ["x"])233        _ = try await store.setFavorite(id: fav, true)234        try await addPage(store, "Autre", tags: ["x"])235        var criteria = SearchCriteria()236        criteria.favoritesOnly = true237        criteria.tags = ["x"]238        let hits = try await store.search(query: criteria.query, filters: criteria.storeFilters())239        #expect(hits.map(\.page.id) == [fav])240    }241242    @Test func recentSearchesAreUniqueAndBounded() {243        var recents: [String] = []244        for index in 0..<12 { recents = RecentSearches.adding("requête \(index)", to: recents) }245        #expect(recents.count == RecentSearches.limit)246        #expect(recents.first == "requête 11")247        recents = RecentSearches.adding("  REQUETE 9 ", to: recents)248        #expect(recents.first == "REQUETE 9")249        #expect(recents.count == RecentSearches.limit)250        #expect(RecentSearches.adding("   ", to: recents) == recents)251    }252}253254@Suite("Coquille")255@MainActor256struct ShellTests {257    @Test func sourcesRoundTripThroughSceneStorage() {258        let sources: [NoteSource] = [.smart(.all), .smart(.trash), .section("research"), .folder("0b7f6c0e-3f0a-4d5e-9b0a-111111111111"), .tag("idée: a")]259        for source in sources { #expect(NoteSource(storageKey: source.storageKey) == source) }260        #expect(NoteSource(storageKey: "smart:nope") == nil)261        #expect(NoteSource(storageKey: "folder:") == nil)262        #expect(NoteSource(storageKey: "") == nil)263        #expect(SidebarItem(storageKey: SidebarItem.search.storageKey) == .search)264        #expect(SidebarItem(storageKey: "tag:x") == .source(.tag("x")))265    }266267    @Test func navigationAdaptsBetweenStackAndColumns() {268        let shell = ShellState(sections: HostedSectionRegistry())269        shell.tab = .notes270        shell.path = []271        shell.open(source: .folder("f"))272        shell.open(note: "n", isNew: true)273        shell.open(note: "n")274        #expect(shell.path == [.list(.folder("f")), .note("n", isNew: true)])275        #expect(shell.currentSource == .folder("f"))276        shell.adapt(toCompact: false)277        #expect(shell.sidebar == .source(.folder("f")))278        #expect(shell.selectedNote == "n")279        #expect(shell.isFresh("n"))280        shell.openSearch("mot")281        #expect(shell.sidebar == .search && shell.searchQuery == "mot")282        shell.adapt(toCompact: true)283        // 2.0: search is a tab; the note shown is pushed on its stack284        #expect(shell.tab == .search && shell.searchQuery == "mot")285        #expect(shell.path == [.note("n", isNew: false)])286        shell.close(note: "n")287        #expect(shell.path.isEmpty)288        #expect(shell.selectedNote == nil)289    }290291    @Test func breadcrumbJumpGoesBackInsteadOfDeeper() {292        let shell = ShellState(sections: HostedSectionRegistry())293        shell.path = [.folders, .list(.folder("a")), .list(.folder("b")), .list(.folder("c"))]294        shell.jump(to: .folder("a"))295        #expect(shell.path == [.folders, .list(.folder("a"))])296        shell.jump(to: .section("notes"))297        #expect(shell.path.last == .list(.section("notes")))298    }299300    @Test func dropsAreAcceptedOnlyWhereTheyMeanSomething() {301        #expect(NoteCommands.accepts(dropOn: .smart(.favorites)))302        #expect(NoteCommands.accepts(dropOn: .smart(.trash)))303        #expect(NoteCommands.accepts(dropOn: .folder("f")))304        #expect(NoteCommands.accepts(dropOn: .section("projects")))305        #expect(!NoteCommands.accepts(dropOn: .section("databases")))306        #expect(!NoteCommands.accepts(dropOn: .smart(.all)))307        #expect(!NoteCommands.accepts(dropOn: .tag("x")))308    }309310    @Test func syncWordingNeverOverstates() {311        var status = SyncStatus()312        #expect(SyncPresentation(status: status, isOnline: true, session: .signedIn).kind == .upToDate)313        status.pending = 3314        let pending = SyncPresentation(status: status, isOnline: true, session: .signedIn)315        #expect(pending.kind == .pending)316        #expect(pending.explanation.contains("Enregistré sur cet appareil"))317        #expect(!pending.explanation.contains("Synchronisé"))318        #expect(SyncPresentation(status: status, isOnline: false, session: .signedIn).kind == .offline)319        status.phase = .syncing320        #expect(SyncPresentation(status: status, isOnline: true, session: .signedIn).kind == .syncing)321        status.phase = .failed("x")322        #expect(SyncPresentation(status: status, isOnline: true, session: .signedIn).kind == .error)323        status.conflicts = 1324        #expect(SyncPresentation(status: status, isOnline: true, session: .signedIn).kind == .conflict)325        #expect(SyncPresentation(status: status, isOnline: true, session: .expired).kind == .sessionEnded)326        #expect(SyncPresentation(status: SyncStatus(), isOnline: true, session: .signedIn).explanation.contains("Synchronisé"))327    }328329    @Test func signInErrorsAreExplained() {330        #expect(SignInFailure(PasskeyError.cancelled).message == nil)331        #expect(SignInFailure(APIError.cancelled).message == nil)332        #expect(SignInFailure(PasskeyError.noCredentials).kind == .noPasskey)333        #expect(SignInFailure(PasskeyError.noCredentials).message?.contains("trousseau iCloud") == true)334        #expect(SignInFailure(PasskeyError.noCredentials).message?.contains("QR") == true)335        #expect(SignInFailure(APIError.offline).kind == .offline)336        #expect(SignInFailure(APIError.http(status: 409, code: "not_enrolled", message: "", body: Data())).kind == .notEnrolled)337        #expect(SignInFailure(APIError.http(status: 429, code: "rate_limited", message: "", body: Data())).kind == .rateLimited)338        #expect(SignInFailure(APIError.http(status: 409, code: "last_passkey", message: "", body: Data())).kind == .lastPasskey)339        #expect(SignInFailure(APIError.timeout).kind == .unreachable)340        #expect(SignInFailure(APIError.http(status: 500, code: nil, message: "boom", body: Data())).message?.contains("boom") == true)341    }342343    @Test func eraseWarningMentionsUnsyncedChanges() {344        #expect(!EraseWarning.message(pending: 0).contains("perdue"))345        #expect(EraseWarning.message(pending: 1).contains("1 modification"))346        #expect(EraseWarning.message(pending: 4).contains("4 modifications"))347    }348349    @Test func appearanceMapsToAColorScheme() {350        #expect(Appearance.system.colorScheme == nil)351        #expect(Appearance.light.colorScheme == .light)352        #expect(Appearance.dark.colorScheme == .dark)353        #expect(NoteTitle.display("Untitled") == AppModel.displayTitle("Untitled"))354        #expect(NoteTitle.display("Titre") == "Titre")355    }356}357
Files main
Menu

Theme