Repository Public
1// File des actions hors ligne : ordre, fusion et annulation des actions opposées, idempotence, fusion à trois voies (le serveur2// gagne), abandon sur refus, liaison à l'utilisateur ; puis le rejeu réel contre un faux serveur JMAP.3import assert from "node:assert/strict"4import { afterEach, test } from "node:test"5import { HttpError, JmapSetError, NetworkError } from "../jmap/errors"6import { S, type Me } from "./app"7import {8 backoffMs, bindOffline, bindUser, emptyQueue, enqueueOps, isTransportFailure, opsFor, overlayEmail, queueOrSend, queueSnapshot, queuedCount, rebaseOps, replay, resolveOp, sameValue, settleOps, startOffline, stopOffline,9 type JmapPatch, type QueueState,10} from "./offline"1112const U = "user-1"13const MB = "mb-1"14const seen = (on: boolean): JmapPatch => ({ "keywords/$seen": on ? true : null })15const flag = (on: boolean): JmapPatch => ({ "keywords/$flagged": on ? true : null })1617test("ordre : une opération par message, dans l'ordre d'entrée", () => {18 let q: QueueState = emptyQueue(U)19 q = enqueueOps(q, U, MB, { a: seen(true) }, { a: seen(false) }, 1)20 q = enqueueOps(q, U, MB, { b: flag(true) }, { b: flag(false) }, 2)21 q = enqueueOps(q, U, "mb-2", { a: flag(true) }, { a: flag(false) }, 3)22 q = enqueueOps(q, U, MB, { a: flag(true) }, { a: flag(false) }, 4)23 assert.deepEqual(opsFor(q, U).map((o) => [o.seq, o.mb, o.id]), [[1, MB, "a"], [2, MB, "b"], [3, "mb-2", "a"]], "la seconde action sur « a » fusionne et garde son rang")24 assert.deepEqual(opsFor(q, U, MB)[0].patch, { "keywords/$seen": true, "keywords/$flagged": true })25 assert.deepEqual(opsFor(q, U, MB)[0].base, { "keywords/$seen": null, "keywords/$flagged": null })26 assert.equal(opsFor(q, U, "mb-2").length, 1, "même identifiant dans une autre boîte : autre message")27})2829test("fusion : deux actions opposées s'annulent ; la dernière valeur l'emporte ; la base la plus ancienne fait foi", () => {30 let q = enqueueOps(emptyQueue(U), U, MB, { a: flag(true) }, { a: flag(false) })31 q = enqueueOps(q, U, MB, { a: flag(false) }, { a: flag(true) })32 assert.equal(q.ops.length, 0, "favori puis retrait du favori : plus rien à envoyer")33 // archive puis annulation (retour dans la boîte de réception)34 q = enqueueOps(q, U, MB, { a: { mailboxIds: { arch: true } } }, { a: { mailboxIds: { inbox: true } } })35 q = enqueueOps(q, U, MB, { a: { mailboxIds: { inbox: true } } }, { a: { mailboxIds: { arch: true } } })36 assert.equal(q.ops.length, 0)37 // archive puis corbeille : une seule opération, vers la corbeille, base = boîte de réception38 q = enqueueOps(q, U, MB, { a: { mailboxIds: { arch: true }, ...seen(true) } }, { a: { mailboxIds: { inbox: true }, ...seen(false) } })39 q = enqueueOps(q, U, MB, { a: { mailboxIds: { trash: true } } }, { a: { mailboxIds: { arch: true } } })40 assert.deepEqual(q.ops[0].patch, { mailboxIds: { trash: true }, "keywords/$seen": true })41 assert.deepEqual(q.ops[0].base, { mailboxIds: { inbox: true }, "keywords/$seen": null })42 // annulation partielle : seul le champ revenu à sa base disparaît43 q = enqueueOps(q, U, MB, { a: seen(false) }, { a: seen(true) })44 assert.deepEqual(q.ops[0].patch, { mailboxIds: { trash: true } })45 // une action sans effet (valeur déjà en place) n'entre pas dans la file46 assert.equal(enqueueOps(emptyQueue(U), U, MB, { z: flag(true) }, { z: flag(true) }).ops.length, 0)47 assert.equal(enqueueOps(emptyQueue(U), U, MB, { z: {} }).ops.length, 0)48})4950test("égalité des valeurs : présence d'un mot-clé, ensemble de dossiers", () => {51 assert.equal(sameValue("keywords/$seen", null, undefined), true)52 assert.equal(sameValue("keywords/$seen", false, null), true)53 assert.equal(sameValue("keywords/$seen", true, null), false)54 assert.equal(sameValue("mailboxIds", { a: true, b: true }, { b: true, a: true }), true)55 assert.equal(sameValue("mailboxIds", { a: true }, { a: true, b: true }), false)56 assert.equal(sameValue("mailboxIds", { a: true, b: false }, { a: true }), true)57})5859test("liaison à l'utilisateur : jamais rejouée pour quelqu'un d'autre", () => {60 const q = enqueueOps(emptyQueue(U), U, MB, { a: flag(true) }, { a: flag(false) })61 assert.equal(opsFor(q, U).length, 1)62 assert.deepEqual(opsFor(q, "user-2"), [])63 assert.deepEqual(opsFor(q, null), [])64 assert.deepEqual(bindUser(q, "user-2"), emptyQueue("user-2"), "file relue du stockage pour un autre utilisateur : abandonnée")65 assert.equal(bindUser(q, U).ops.length, 1)66 assert.deepEqual(bindUser(null, U), emptyQueue(U))67 assert.deepEqual(bindUser({ user: U, seq: 3, ops: [{ ...q.ops[0], user: "user-2" }] }, U).ops, [], "une opération étrangère glissée dans la file est écartée")68 // une action d'un autre utilisateur repart d'une file vide69 const other = enqueueOps(q, "user-2", MB, { b: flag(true) }, { b: flag(false) })70 assert.deepEqual(other.ops.map((o) => [o.user, o.id]), [["user-2", "b"]])71})7273test("fusion à trois voies : envoi, déjà appliqué (idempotence), conflit (le serveur gagne), message disparu", () => {74 const op = { patch: { "keywords/$flagged": true, mailboxIds: { arch: true } }, base: { "keywords/$flagged": null, mailboxIds: { inbox: true } } }75 assert.deepEqual(resolveOp(op, { keywords: {}, mailboxIds: { inbox: true } }), { send: op.patch, conflicts: [], applied: [], gone: false })76 // rejeu après une réponse perdue : le serveur a déjà tout77 assert.deepEqual(resolveOp(op, { keywords: { $flagged: true }, mailboxIds: { arch: true } }), { send: {}, conflicts: [], applied: ["keywords/$flagged", "mailboxIds"], gone: false })78 // le serveur a déplacé le message entre-temps : son choix reste, le favori (non touché là-bas) passe79 const r = resolveOp(op, { keywords: {}, mailboxIds: { trash: true } })80 assert.deepEqual(r.send, { "keywords/$flagged": true })81 assert.deepEqual(r.conflicts, ["mailboxIds"])82 assert.equal(resolveOp(op, null).gone, true)83 // sans base connue pour un champ, pas de détection de conflit : la valeur est envoyée84 assert.deepEqual(resolveOp({ patch: { "keywords/x": true }, base: {} }, { keywords: {}, mailboxIds: {} }).send, { "keywords/x": true })85})8687test("règlement et changement de base ; délais ; recouvrement de l'affichage ; pannes de transport", () => {88 let q = enqueueOps(emptyQueue(U), U, MB, { a: flag(true), b: flag(true) }, { a: flag(false), b: flag(false) })89 const inFlight = [...q.ops]90 // pendant l'envoi, « a » reçoit une autre action : son opération est remplacée (nouvel objet)91 q = enqueueOps(q, U, MB, { a: seen(true) }, { a: seen(false) })92 q = rebaseOps(settleOps(q, inFlight), new Map([[`${MB}\na`, flag(true)]]))93 assert.deepEqual(q.ops.map((o) => [o.id, o.patch]), [["a", { "keywords/$seen": true }]], "le favori accepté quitte l'opération ; « b », inchangée, est réglée")94 assert.deepEqual([0, 1, 2, 3, 9, 50].map(backoffMs), [2000, 4000, 8000, 16000, 60000, 60000])95 const e = { id: "a", keywords: { $seen: true } as Record<string, boolean>, mailboxIds: { inbox: true } as Record<string, boolean> }96 assert.equal(overlayEmail(e, { "keywords/$seen": true, mailboxIds: { inbox: true } }), e, "rien à changer : même objet")97 assert.deepEqual(overlayEmail(e, { "keywords/$seen": null, "keywords/$flagged": true, mailboxIds: { arch: true } }), { id: "a", keywords: { $flagged: true }, mailboxIds: { arch: true } })98 assert.equal(isTransportFailure(new NetworkError()), true)99 assert.equal(isTransportFailure(new HttpError(503, "mail_server_unavailable")), true)100 assert.equal(isTransportFailure(new HttpError(403, "forbidden")), false)101 assert.equal(isTransportFailure(new JmapSetError("Email/set", { type: "notFound" })), false)102})103104// ---------------------------------------------------------------- exécution contre un faux serveur105type Mail = { id: string; keywords: Record<string, boolean>; mailboxIds: Record<string, boolean> }106function fakeServer(mails: Mail[]) {107 const store = new Map(mails.map((m) => [m.id, structuredClone(m)]))108 const sets: Record<string, JmapPatch>[] = []109 let down = false110 const apply = (update: Record<string, JmapPatch>) => {111 const notUpdated: Record<string, { type: string }> = {}112 for (const [id, patch] of Object.entries(update)) {113 const m = store.get(id)114 if (!m) {115 notUpdated[id] = { type: "notFound" }116 continue117 }118 for (const [k, v] of Object.entries(patch)) {119 if (k === "mailboxIds") m.mailboxIds = { ...(v as Record<string, boolean>) }120 else if (v) m.keywords[k.slice(9)] = true121 else delete m.keywords[k.slice(9)]122 }123 }124 return notUpdated125 }126 const call = async (name: string, args: any): Promise<any> => {127 if (down) throw new NetworkError()128 if (name === "Email/get") return { list: (args.ids as string[]).flatMap((id) => (store.has(id) ? [structuredClone(store.get(id)!)] : [])), notFound: (args.ids as string[]).filter((id) => !store.has(id)) }129 if (name === "Email/set") {130 sets.push(structuredClone(args.update))131 return { notUpdated: apply(args.update) }132 }133 throw new Error(`unexpected ${name}`)134 }135 return { store, sets, call, setDown: (v: boolean) => (down = v), apply }136}137const setOnline = (on: boolean) => Object.defineProperty(globalThis.navigator, "onLine", { value: on, configurable: true })138const me = (id: string): Me => ({ user: { id, handle: id, display_name: id, role: "member", prefs: {} }, mailboxes: [{ id: MB, address: "a@x", display_name: "A" }] }) as unknown as Me139const toasts = () => S.get().toasts.map((x) => x.text)140141async function setup(mails: Mail[], user = U) {142 const srv = fakeServer(mails)143 const refreshed: string[] = []144 S.set({ me: me(user), toasts: [], mb: null, sync: { pendingOps: 0, busy: false, error: null } })145 bindOffline({146 send: async (_mb, patches) => {147 const r = await srv.call("Email/set", { update: patches })148 const bad = Object.values(r.notUpdated)[0] as { type: string } | undefined149 if (bad) throw new JmapSetError("Email/set", bad)150 },151 client: () => ({ call: srv.call }) as never,152 refresh: (mb) => void refreshed.push(mb),153 })154 await startOffline(user)155 return { srv, refreshed }156}157afterEach(() => {158 stopOffline()159 setOnline(true)160 S.set({ me: null, toasts: [] })161})162163test("en ligne : envoi direct, rien en file ; un refus du serveur remonte à l'appelant", async () => {164 const { srv } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }])165 assert.equal(await queueOrSend(MB, { a: flag(true) }, { a: flag(false) }), "sent")166 assert.equal(queuedCount(), 0)167 assert.equal(srv.store.get("a")!.keywords.$flagged, true)168 await assert.rejects(queueOrSend(MB, { zz: flag(true) }, { zz: flag(false) }), JmapSetError)169 assert.equal(queuedCount(), 0, "un refus n'est jamais mis en file")170})171172test("hors ligne : mis en file, compté par l'indicateur, rejoué une seule fois dans l'ordre à la reconnexion", async () => {173 const { srv, refreshed } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }, { id: "b", keywords: {}, mailboxIds: { inbox: true } }])174 setOnline(false)175 assert.equal(await queueOrSend(MB, { a: seen(true) }, { a: seen(false) }), "queued")176 assert.equal(await queueOrSend(MB, { b: { mailboxIds: { arch: true } } }, { b: { mailboxIds: { inbox: true } } }), "queued")177 assert.equal(await queueOrSend(MB, { a: flag(true) }, { a: flag(false) }), "queued")178 assert.equal(queuedCount(), 2)179 assert.equal(S.get().sync.queued, 2)180 assert.equal(srv.sets.length, 0, "rien n'est parti")181 await replay()182 assert.equal(srv.sets.length, 0, "toujours hors ligne : aucun essai")183 setOnline(true)184 await replay()185 assert.deepEqual(srv.sets, [{ a: { "keywords/$seen": true, "keywords/$flagged": true }, b: { mailboxIds: { arch: true } } }])186 assert.deepEqual(Object.keys(srv.sets[0]), ["a", "b"], "ordre d'entrée")187 assert.equal(queuedCount(), 0)188 assert.equal(S.get().sync.queued, 0)189 assert.deepEqual(refreshed, [MB], "les lignes touchées sont relues après le rejeu")190 await replay()191 assert.equal(srv.sets.length, 1, "exactement une fois")192 assert.deepEqual(toasts(), [])193})194195test("panne de transport en ligne : mis en file ; les actions suivantes attendent derrière (ordre) ; reprise avec délai", async () => {196 const { srv } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }, { id: "b", keywords: {}, mailboxIds: { inbox: true } }])197 srv.setDown(true)198 assert.equal(await queueOrSend(MB, { a: flag(true) }, { a: flag(false) }), "queued")199 srv.setDown(false)200 const before = srv.sets.length201 assert.equal(await queueOrSend(MB, { b: flag(true) }, { b: flag(false) }), "queued", "une action ne double jamais celles qui attendent")202 assert.equal(srv.sets.length, before)203 srv.setDown(true)204 await replay()205 assert.equal(queuedCount(), 2, "échec de transport : tout reste en file")206 srv.setDown(false)207 await replay()208 assert.equal(queuedCount(), 0)209 assert.equal(srv.store.get("a")!.keywords.$flagged && srv.store.get("b")!.keywords.$flagged, true)210})211212test("idempotence : une réponse perdue puis un second rejeu n'écrivent pas deux fois", async () => {213 const { srv } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }])214 setOnline(false)215 await queueOrSend(MB, { a: flag(true) }, { a: flag(false) })216 setOnline(true)217 // le serveur a appliqué le correctif, mais la réponse n'est jamais arrivée218 srv.apply({ a: flag(true) })219 await replay()220 assert.equal(srv.sets.length, 0, "déjà à la valeur voulue : aucun Email/set")221 assert.equal(queuedCount(), 0)222 assert.deepEqual(toasts(), [], "ni conflit ni refus signalé")223})224225test("conflit : le serveur gagne, l'action locale est abandonnée et signalée une fois", async () => {226 const { srv, refreshed } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }])227 setOnline(false)228 await queueOrSend(MB, { a: { mailboxIds: { arch: true } } }, { a: { mailboxIds: { inbox: true } } })229 // pendant ce temps, un autre appareil met le message à la corbeille230 srv.apply({ a: { mailboxIds: { trash: true } } })231 setOnline(true)232 await replay()233 assert.equal(srv.sets.length, 0, "rien n'écrase le choix du serveur")234 assert.deepEqual(srv.store.get("a")!.mailboxIds, { trash: true })235 assert.equal(queuedCount(), 0)236 assert.equal(toasts().length, 1)237 assert.match(toasts()[0], /remplacée par un changement plus récent/)238 assert.deepEqual(refreshed, [MB])239})240241test("refus définitif : opération retirée, signalée une seule fois, les autres passent", async () => {242 const { srv } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }, { id: "gone", keywords: {}, mailboxIds: { inbox: true } }])243 setOnline(false)244 await queueOrSend(MB, { gone: flag(true), a: flag(true) }, { gone: flag(false), a: flag(false) })245 srv.store.delete("gone") // supprimé définitivement ailleurs246 setOnline(true)247 await replay()248 assert.equal(queuedCount(), 0, "le refus ne bloque pas la file")249 assert.equal(srv.store.get("a")!.keywords.$flagged, true)250 assert.equal(toasts().length, 1)251 assert.match(toasts()[0], /n'a pas pu être appliquée/)252 await replay()253 assert.equal(toasts().length, 1, "signalé une seule fois")254})255256test("changement d'utilisateur : la file du précédent n'est jamais rejouée ; perte de session : file vidée", async () => {257 const { srv } = await setup([{ id: "a", keywords: {}, mailboxIds: { inbox: true } }])258 setOnline(false)259 await queueOrSend(MB, { a: flag(true) }, { a: flag(false) })260 assert.equal(queuedCount(), 1)261 // même page, un autre utilisateur se retrouve connecté sans que la file ait été arrêtée262 S.set({ me: me("user-2") })263 assert.equal(queuedCount(), 0, "invisible pour un autre utilisateur")264 setOnline(true)265 await replay()266 assert.equal(srv.sets.length, 0, "jamais rejouée pour un autre utilisateur")267 S.set({ me: me(U) })268 stopOffline()269 assert.deepEqual(queueSnapshot(), emptyQueue(), "perte de session : plus rien en mémoire")270 await replay()271 assert.equal(srv.sets.length, 0)272 // sans utilisateur connecté, rien n'est mis en file273 S.set({ me: null })274 setOnline(false)275 await assert.rejects(queueOrSend(MB, { a: flag(true) }), NetworkError)276})277