Repository Public
1// Tests de l'état « Next » : fermeture d'un brouillon hors ligne, courses au changement de boîte, relecture des pages visibles,2// synchronisation par delta, retrait d'une boîte, rang de boîte stable, préférences d'appareil, indicateur de synchronisation.3import assert from "node:assert/strict"4import { beforeEach, test } from "node:test"5import { JmapClient } from "../jmap/client"6import { NetworkError } from "../jmap/errors"7import type { EmailSummary, Invocation, Mailbox } from "../jmap/types"8import { S, defaultPrefs, emptyList, normalizePrefs, resolveMailboxIndex, type Account, type Draft, type Me } from "./app"9import { closeDraft, saveDraft } from "./composer"10import { PANE_LIMITS, clampPane, defaultDevice, normalizeDevice, pushRecentSearch } from "./device"11import { attachClient, ensureRange, hasClient, openList, refreshList, setFlag, syncEmails, teardownAccount } from "./mail"12import { syncStatus } from "./sync"1314// ---------------------------------------------------------------- faux serveur JMAP (en mémoire, références de résultat comprises)15const folder = (id: string, role: string | null): Mailbox => ({ id, name: id, parentId: null, role, sortOrder: 0, totalEmails: 0, unreadEmails: 0, totalThreads: 0, unreadThreads: 0, isSubscribed: true, myRights: { mayReadItems: true, mayAddItems: true, mayRemoveItems: true, maySetSeen: true, maySetKeywords: true, mayCreateChild: true, mayRename: true, mayDelete: true, maySubmit: true } })16const FOLDERS = [folder("in", "inbox"), folder("dr", "drafts"), folder("tr", "trash"), folder("ar", "archive")]17const mail = (id: string, box = "in", keywords: string[] = [], subject = `Objet ${id}`): EmailSummary => ({ id, blobId: `b${id}`, threadId: `t${id}`, mailboxIds: { [box]: true }, keywords: Object.fromEntries(keywords.map((k) => [k, true])), size: 1, receivedAt: "2026-01-01T00:00:00Z", from: [{ name: "A", email: "a@example.org" }], to: null, subject, preview: "", hasAttachment: false })1819type Handler = (name: string, args: Record<string, unknown>) => unknown | Promise<unknown>20class FakeError extends Error {21 constructor(public type: string) {22 super(type)23 }24}25/** Client réel (lots, références) dont seul le transport est remplacé. */26function fakeClient(mb: string, handler: Handler, log: string[] = []): JmapClient {27 const c = new JmapClient(mb)28 c.accountId = `acc-${mb}`29 c.raw = async (_using, calls) => {30 const out: Invocation[] = []31 const byId = new Map<string, Record<string, unknown>>()32 for (const [name, rawArgs, callId] of calls) {33 const args: Record<string, unknown> = {}34 for (const [k, v] of Object.entries(rawArgs)) {35 if (!k.startsWith("#")) {36 args[k] = v37 continue38 }39 const ref = v as { resultOf: string; path: string }40 const source = byId.get(ref.resultOf)41 // comme un vrai serveur : une référence vers un appel en échec est elle-même une erreur42 args[k.slice(1)] = source ? pick(source, ref.path.split("/").filter(Boolean)) : new FakeError("invalidResultReference")43 }44 log.push(name)45 try {46 const broken = Object.values(args).find((v) => v instanceof FakeError)47 if (broken) throw broken48 const r = (await handler(name, args)) as Record<string, unknown>49 byId.set(callId, r)50 out.push([name, r, callId])51 } catch (e) {52 if (e instanceof FakeError) out.push(["error", { type: e.type }, callId])53 else throw e54 }55 }56 return out57 }58 return c59}60function pick(value: unknown, path: string[]): unknown {61 if (!path.length) return value62 const [head, ...rest] = path63 if (head === "*") return (value as unknown[]).flatMap((v) => pick(v, rest))64 return pick((value as Record<string, unknown>)?.[head], rest)65}6667/** Boîte de réception factice : requêtes, lectures, changements et delta, pilotés par le test. */68function inboxServer(emails: Map<string, EmailSummary>, order: () => string[]) {69 const st = { queryState: "q1", emailState: "s1", changes: { updated: [] as string[], created: [] as string[], destroyed: [] as string[] }, queryChanges: null as null | "cannot" | { removed: string[]; added: { id: string; index: number }[] }, positions: [] as number[] }70 const handler: Handler = (name, args) => {71 switch (name) {72 case "Email/query": {73 const position = (args.position as number) ?? 074 st.positions.push(position)75 const all = order()76 return { queryState: st.queryState, canCalculateChanges: true, position, ids: all.slice(position, position + ((args.limit as number) ?? 50)), total: all.length }77 }78 case "Email/get": {79 const ids = (args.ids as string[]) ?? []80 return { state: st.emailState, list: ids.map((id) => emails.get(id)).filter(Boolean), notFound: ids.filter((id) => !emails.has(id)) }81 }82 case "Thread/get":83 return { state: "t", list: (args.ids as string[]).map((id) => ({ id, emailIds: [id.slice(1)] })), notFound: [] }84 case "Email/changes":85 return { oldState: args.sinceState, newState: st.emailState, hasMoreChanges: false, ...st.changes }86 case "Email/queryChanges":87 if (!st.queryChanges || st.queryChanges === "cannot") throw new FakeError("cannotCalculateChanges")88 return { oldQueryState: args.sinceQueryState, newQueryState: st.queryState, total: order().length, ...st.queryChanges }89 default:90 throw new Error(`appel inattendu : ${name}`)91 }92 }93 return { st, handler }94}9596const ME: Me = { user: { id: "u", handle: "owner", display_name: "Owner", role: "member", prefs: {} }, session: { id: "s", kind: "web" }, mailboxes: [{ id: "A", address: "a@example.org", display_name: "A", position: 0 }, { id: "B", address: "b@example.org", display_name: "B", position: 1 }], version: "test" }97const account = (id: string): Account => ({ id, status: "ready", stale: false, folders: FOLDERS, identities: [], quota: [], mailboxState: "m1", emailState: "s1", push: "open" })98const tick = () => new Promise((r) => setTimeout(r, 0))99async function until(cond: () => boolean) {100 for (let i = 0; i < 200 && !cond(); i++) await tick()101 assert.ok(cond(), "condition jamais atteinte")102}103104beforeEach(() => {105 if (hasClient("A")) teardownAccount("A")106 if (hasClient("B")) teardownAccount("B")107 S.set({ phase: "ready", online: true, me: ME, all: false, mb: "A", view: "inbox", query: "", accounts: { A: account("A"), B: account("B") }, list: emptyList(), emails: {}, threads: {}, threadShown: {}, selected: new Set(), cursor: null, open: null, draft: null, toasts: [], sync: { pendingOps: 0, busy: false, error: null } })108})109110// ---------------------------------------------------------------- A1 : fermeture d'un brouillon111test("A1 — fermer la rédaction hors ligne ne perd rien : brouillon gardé (réduit) et copie locale conservée", async () => {112 const store = new Map<string, string>()113 ;(globalThis as { localStorage?: unknown }).localStorage = { getItem: (k: string) => store.get(k) ?? null, setItem: (k: string, v: string) => void store.set(k, v), removeItem: (k: string) => void store.delete(k) }114 let online = false115 attachClient("A", fakeClient("A", (name) => {116 if (!online) throw new NetworkError()117 assert.equal(name, "Email/set")118 return { created: { d: { id: "draft-1" } }, notCreated: null }119 }))120 const draft: Draft = { key: "k1", mb: "A", identityId: null, from: null, to: [{ email: "x@example.org" }], cc: [], bcc: [], showCc: false, subject: "À ne pas perdre", mode: "text", html: "", text: "Texte important", attachments: [], inReplyTo: null, references: null, related: null, draftEmailId: null, save: "dirty", savedAt: null, send: "idle", sendError: null, minimized: false, rev: 0 }121 S.set({ draft })122 assert.equal(await closeDraft(), false, "l'enregistrement a échoué : la rédaction n'est pas fermée")123 const kept = S.get().draft124 assert.ok(kept, "le brouillon reste dans l'état")125 assert.equal(kept.text, "Texte important")126 assert.equal(kept.minimized, true)127 assert.equal(kept.save, "error")128 const local = JSON.parse(store.get("spmail.draft") ?? "null") as Draft | null129 assert.equal(local?.text, "Texte important", "la copie locale survit à la fermeture (reprise au prochain démarrage)")130 // retour du réseau : l'enregistrement réussit, la fermeture efface alors la copie locale131 online = true132 await saveDraft()133 assert.equal(S.get().draft?.save, "saved")134 assert.equal(S.get().draft?.draftEmailId, "draft-1")135 assert.equal(await closeDraft(), true)136 assert.equal(S.get().draft, null)137 assert.equal(store.has("spmail.draft"), false)138 delete (globalThis as { localStorage?: unknown }).localStorage139})140141// ---------------------------------------------------------------- A4 : courses au changement de boîte142test("A4 — l'annulation d'une action qui échoue n'écrit pas dans l'état d'une autre boîte", async () => {143 let fail: (e: Error) => void = () => {}144 attachClient("A", fakeClient("A", () => new Promise((_, reject) => (fail = reject))))145 const a1 = mail("e1", "in")146 S.set({ emails: { e1: a1 }, list: { ...emptyList("A|inbox|"), ids: ["e1"], total: 1, loadingFirst: false } })147 const done = setFlag(["e1"], true)148 await until(() => !!S.get().emails.e1?.keywords.$flagged) // effet immédiat à l'écran149 assert.equal(S.get().sync.pendingOps, 1, "modification comptée « en attente »")150 // la personne passe à la boîte B, où le même identifiant JMAP désigne un autre message151 const b1 = mail("e1", "in", ["$seen"], "Message de B")152 S.set({ mb: "B", emails: { e1: b1 }, list: { ...emptyList("B|inbox|"), ids: ["e1"], total: 1, loadingFirst: false } })153 fail(new NetworkError())154 await done155 assert.equal(S.get().emails.e1, b1, "le message de B est intact (ni mots-clés ni dossiers de A)")156 assert.equal(S.get().sync.pendingOps, 0)157})158159test("A4 — une synchronisation qui répond après un changement de boîte n'écrit pas dans la nouvelle liste", async () => {160 let release: (v: unknown) => void = () => {}161 let asked = false162 attachClient("A", fakeClient("A", (name) => {163 if (name === "Email/changes") return { oldState: "s1", newState: "s2", hasMoreChanges: false, created: [], updated: ["e1"], destroyed: [] }164 asked = true165 return new Promise((resolve) => (release = resolve))166 }))167 S.set({ emails: { e1: mail("e1") }, list: { ...emptyList("A|inbox|"), ids: ["e1"], total: 1, loadingFirst: false } })168 const done = syncEmails("A")169 await until(() => asked)170 const b1 = mail("e1", "in", [], "Message de B")171 S.set({ mb: "B", emails: { e1: b1 }, list: { ...emptyList("B|inbox|"), ids: ["e1"], total: 1, loadingFirst: false } })172 release({ state: "s2", list: [mail("e1", "ar", ["$seen", "$flagged"], "Message de A")], notFound: [] })173 await done174 assert.equal(S.get().emails.e1, b1)175 assert.equal(S.get().accounts.A.emailState, "s2", "l'état du compte A, lui, avance bien")176})177178// ---------------------------------------------------------------- A2 : relecture autour de la fenêtre visible179test("A2 — après un changement, les pages relues sont celles de la fenêtre visible", async () => {180 const emails = new Map(Array.from({ length: 10000 }, (_, i) => [`e${i}`, mail(`e${i}`)] as const))181 const order = [...emails.keys()]182 const { st, handler } = inboxServer(emails, () => order)183 attachClient("A", fakeClient("A", handler))184 openList("A", "inbox", "")185 await until(() => S.get().list.total === 10000)186 ensureRange(5010, 5040) // on défile au milieu187 await until(() => !!S.get().list.ids[5010])188 st.positions.length = 0189 await refreshList()190 assert.deepEqual([...st.positions].sort((a, b) => a - b), [5000], "la page affichée (100), pas les pages 0 à 3")191 // la première page, hors de vue, a été oubliée : elle est relue quand on y revient192 st.positions.length = 0193 ensureRange(0, 20)194 await until(() => st.positions.includes(0))195})196197// ---------------------------------------------------------------- A11 : synchronisation par delta198test("A11 — un message lu ailleurs est corrigé sur place, sans relire la liste (Email/queryChanges)", async () => {199 const emails = new Map([["e1", mail("e1")], ["e2", mail("e2")]])200 let order = ["e1", "e2"]201 const { st, handler } = inboxServer(emails, () => order)202 const log: string[] = []203 attachClient("A", fakeClient("A", handler, log))204 openList("A", "inbox", "")205 await until(() => S.get().list.total === 2)206 const idsBefore = S.get().list.ids207 // un autre appareil marque e1 comme lu208 emails.set("e1", mail("e1", "in", ["$seen"]))209 Object.assign(st, { emailState: "s2", queryState: "q2", changes: { created: [], updated: ["e1"], destroyed: [] }, queryChanges: { removed: [], added: [] } })210 log.length = 0211 await syncEmails("A")212 assert.equal(S.get().emails.e1.keywords.$seen, true, "ligne corrigée")213 assert.equal(S.get().list.ids, idsBefore, "la liste n'a pas été recomposée (même tableau : aucun clignotement)")214 assert.ok(!log.includes("Email/query"), `aucune relecture de liste, appels : ${log.join(", ")}`)215 assert.ok(log.includes("Email/queryChanges"))216217 // un nouveau message arrive : inséré en tête par le delta, toujours sans Email/query218 emails.set("e3", mail("e3"))219 order = ["e3", "e1", "e2"]220 Object.assign(st, { emailState: "s3", queryState: "q3", changes: { created: ["e3"], updated: [], destroyed: [] }, queryChanges: { removed: [], added: [{ id: "e3", index: 0 }] } })221 S.set((s) => ({ accounts: { ...s.accounts, A: { ...s.accounts.A, emailState: "s2" } } }))222 log.length = 0223 await syncEmails("A")224 assert.deepEqual(Array.from(S.get().list.ids), ["e3", "e1", "e2"])225 assert.equal(S.get().list.total, 3)226 assert.ok(S.get().emails.e3)227 assert.ok(!log.includes("Email/query"), `appels : ${log.join(", ")}`)228})229230test("A11 — repli : sans delta possible, la liste n'est relue que si la modification la concerne", async () => {231 const emails = new Map([["e1", mail("e1")], ["e2", mail("e2")]])232 let order = ["e1", "e2"]233 const { st, handler } = inboxServer(emails, () => order)234 const log: string[] = []235 attachClient("A", fakeClient("A", handler, log))236 openList("A", "inbox", "")237 await until(() => S.get().list.total === 2)238 st.queryChanges = "cannot"239 // favori posé ailleurs : la composition de la boîte de réception ne change pas → pas de relecture240 emails.set("e2", mail("e2", "in", ["$flagged"]))241 Object.assign(st, { emailState: "s2", changes: { created: [], updated: ["e2"], destroyed: [] } })242 log.length = 0243 await syncEmails("A")244 assert.equal(S.get().emails.e2.keywords.$flagged, true)245 assert.ok(log.includes("Email/queryChanges") && !log.includes("Email/query"), `appels : ${log.join(", ")}`)246 // (après un refus, l'état de requête est oublié : le delta n'est plus demandé tant qu'aucune page n'a été relue)247 S.set((s) => ({ accounts: { ...s.accounts, A: { ...s.accounts.A, emailState: "s2" } } }))248 emails.set("e2", mail("e2", "in", ["$flagged", "$seen"]))249 Object.assign(st, { emailState: "s3", changes: { created: [], updated: ["e2"], destroyed: [] } })250 log.length = 0251 await syncEmails("A")252 assert.equal(S.get().emails.e2.keywords.$seen, true)253 assert.deepEqual(log, ["Email/changes", "Email/get"], "ni Email/queryChanges (refusé une fois) ni Email/query")254 // archivé ailleurs : la liste est concernée → relue255 emails.set("e1", mail("e1", "ar"))256 order = ["e2"]257 Object.assign(st, { emailState: "s4", changes: { created: [], updated: ["e1"], destroyed: [] } })258 S.set((s) => ({ accounts: { ...s.accounts, A: { ...s.accounts.A, emailState: "s3" } } }))259 log.length = 0260 await syncEmails("A")261 assert.ok(log.includes("Email/query"))262 assert.deepEqual(Array.from(S.get().list.ids), ["e2"])263 assert.equal(S.get().list.total, 1)264})265266// ---------------------------------------------------------------- A5 : boîte retirée, rang stable267test("A5 — une boîte retirée est démontée : client, compte, liste affichée", () => {268 attachClient("A", fakeClient("A", () => ({})))269 attachClient("B", fakeClient("B", () => ({})))270 S.set({ mb: "B", emails: { e1: mail("e1") }, list: { ...emptyList("B|inbox|"), ids: ["e1"], total: 1 }, me: { ...ME, mailboxes: [ME.mailboxes[0]] } })271 teardownAccount("B")272 assert.equal(hasClient("B"), false)273 assert.equal(hasClient("A"), true)274 assert.equal(S.get().accounts.B, undefined)275 assert.equal(S.get().mb, null, "plus de boîte courante : la session ramène à une boîte qui existe")276 assert.deepEqual(S.get().emails, {})277 assert.deepEqual(Array.from(S.get().list.ids), [])278})279280test("A5 — le rang de l'adresse suit l'identifiant stable de la boîte", () => {281 const boxes = [{ id: "A" }, { id: "B" }, { id: "C" }]282 assert.deepEqual(resolveMailboxIndex(boxes, 1, "B"), { index: 1, redirect: false, gone: false })283 // une boîte a été insérée devant : /m/1/… désignait B, qui est maintenant au rang 2284 assert.deepEqual(resolveMailboxIndex([{ id: "A" }, { id: "X" }, { id: "B" }], 1, "B"), { index: 2, redirect: true, gone: false })285 // la boîte visée a été retirée : première boîte, et on le sait286 assert.deepEqual(resolveMailboxIndex([{ id: "A" }, { id: "C" }], 1, "B"), { index: 0, redirect: true, gone: true })287 // signet sans identifiant mémorisé : le rang est pris tel quel, borné288 assert.deepEqual(resolveMailboxIndex(boxes, 2, null), { index: 2, redirect: false, gone: false })289 assert.deepEqual(resolveMailboxIndex(boxes, 7, undefined), { index: 0, redirect: true, gone: false })290 assert.deepEqual(resolveMailboxIndex([], 3, "B"), { index: 0, redirect: true, gone: true })291})292293// ---------------------------------------------------------------- préférences294test("préférences : nouveaux réglages normalisés, valeurs inconnues ramenées au défaut", () => {295 assert.deepEqual(normalizePrefs({}), defaultPrefs())296 const p = normalizePrefs({ theme: "midnight", density: "cozy", textSize: "xlarge", readingFont: "serif", previewLines: 2, avatars: false, darkMessages: true })297 assert.deepEqual([p.theme, p.density, p.textSize, p.readingFont, p.previewLines, p.avatars, p.darkMessages], ["midnight", "cozy", "xlarge", "serif", 2, false, true])298 const bad = normalizePrefs({ theme: "neon", density: "tiny", textSize: 14, readingFont: "comic", previewLines: 5, avatars: "no", darkMessages: 1 })299 assert.deepEqual([bad.theme, bad.density, bad.textSize, bad.readingFont, bad.previewLines, bad.avatars, bad.darkMessages], ["system", "comfortable", "default", "system", 1, true, false])300 // un client 0.3.0 n'écrit que theme et density : le reste garde ses défauts301 assert.equal(normalizePrefs({ theme: "dark", density: "compact" }).previewLines, 1)302})303304test("préférences d'appareil : volets bornés, disposition, recherches récentes", () => {305 assert.deepEqual(normalizeDevice(null), defaultDevice())306 const d = normalizeDevice({ layout: "below", paneWidths: { sidebar: 5000, list: 10, listHeight: "x" }, sidebarCollapsed: true, reduceTransparency: true, foldersCollapsed: ["f1", 3, ""], recentSearches: ["a", "b"] })307 assert.equal(d.layout, "below")308 assert.deepEqual(d.paneWidths, { sidebar: PANE_LIMITS.sidebar.max, list: PANE_LIMITS.list.min, listHeight: PANE_LIMITS.listHeight.initial })309 assert.equal(d.sidebarCollapsed, true)310 assert.equal(d.reduceTransparency, true)311 assert.deepEqual(d.foldersCollapsed, ["f1"])312 assert.equal(normalizeDevice({ layout: "diagonal" }).layout, "right")313 assert.equal(normalizeDevice({}).reduceTransparency, null, "par défaut : suit le système")314 assert.equal(normalizeDevice({}).theme, null, "aucun thème choisi sur l'appareil : celui du compte s'applique")315 assert.equal(normalizeDevice({ theme: "midnight" }).theme, "midnight")316 assert.equal(normalizeDevice({ theme: "neon" }).theme, null)317 assert.equal(clampPane("sidebar", 263.6), 264)318 assert.equal(clampPane("list", Number.NaN), PANE_LIMITS.list.initial)319 assert.deepEqual(pushRecentSearch(["facture", "Québec"], " québec "), ["québec", "facture"])320 assert.equal(pushRecentSearch(Array.from({ length: 8 }, (_, i) => `q${i}`), "neuf").length, 8)321 assert.deepEqual(pushRecentSearch(["a"], " "), ["a"])322})323324// ---------------------------------------------------------------- indicateur de synchronisation325test("indicateur : états tirés de l'état réel, rien quand tout est à jour", () => {326 const base = { online: true, offlineShell: false, accounts: { A: account("A"), B: account("B") }, sync: { pendingOps: 0, busy: false, error: null }, draft: null } as const327 assert.deepEqual(syncStatus(base), { kind: "idle" })328 assert.deepEqual(syncStatus({ ...base, online: false }), { kind: "offline", pending: 0 })329 assert.deepEqual(syncStatus({ ...base, online: false, sync: { pendingOps: 2, busy: false, error: null }, draft: { save: "dirty" } as Draft }), { kind: "offline", pending: 3 })330 assert.deepEqual(syncStatus({ ...base, accounts: { A: { ...account("A"), status: "error", error: "mailServer" }, B: account("B") } }), { kind: "error", error: "mailServer" })331 assert.deepEqual(syncStatus({ ...base, accounts: { A: { ...account("A"), status: "error" }, B: { ...account("B"), status: "error" } } }), { kind: "server" })332 assert.deepEqual(syncStatus({ ...base, offlineShell: true }), { kind: "server" })333 assert.deepEqual(syncStatus({ ...base, sync: { pendingOps: 0, busy: false, error: "offline" } }), { kind: "error", error: "offline" })334 assert.deepEqual(syncStatus({ ...base, accounts: { A: { ...account("A"), push: "retrying" }, B: account("B") } }), { kind: "reconnecting" })335 assert.deepEqual(syncStatus({ ...base, sync: { pendingOps: 1, busy: false, error: null } }), { kind: "syncing", pending: 1 })336 assert.deepEqual(syncStatus({ ...base, sync: { pendingOps: 0, busy: true, error: null } }), { kind: "syncing", pending: 0 })337})338