SPB Git

Repository Public

next.test.ts 21.3 KB 338 lines typescript

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

Theme