Repository Public
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