Repository Public
1// Tests purs de la couche d'intelligence côté client : forme des réglages et des sorties, états d'erreur, file de tri, texte → HTML de brouillon.2import assert from "node:assert/strict"3import { test } from "node:test"4import { JSDOM } from "jsdom"5import { HttpError, NetworkError } from "../jmap/errors"6import {7 AI_OFF, aiAnyOn, aiFailure, aiOn, confirmedSettings, createTriageQueue, insertSuggestion, normalizeIndexStatus, normalizeMessage, normalizeReplies, normalizeSettings, normalizeSummary, normalizeTriage,8 normalizeUsage, normalizeWrite, reminderDue, summaryIsEmpty, textToDraftHtml, writeBody, type TriageBatch,9} from "./ai"1011const HOSTILE = '<img src=x onerror="window.__pwned=1"> [cliquez ici](javascript:alert(1)) **gras** <script>window.__pwned=1</script>'1213test("normalizeSettings : forme inattendue → tout coupé ; valeurs connues gardées", () => {14 assert.deepEqual(normalizeSettings(null), AI_OFF)15 assert.deepEqual(normalizeSettings("oui"), AI_OFF)16 assert.equal(normalizeSettings({ provider: "openai" }).provider, "off")17 const s = normalizeSettings({ provider: "local", consent_external_at: null, language: "fr", features: { summary: true, reply: "yes", triage: 1, semantic: true }, available: { local: true, anthropic: false, semantic: false }, extra: 1 })18 assert.equal(s.provider, "local")19 assert.equal(s.language, "fr")20 assert.deepEqual(s.features, { summary: true, reply: false, write: false, triage: false, semantic: true })21 assert.deepEqual(s.available, { local: true, anthropic: false, semantic: false })22 assert.equal(normalizeSettings({ language: "de" }).language, "auto")23})2425test("aiOn : fournisseur coupé, fonction décochée, consentement manquant, index indisponible → rien", () => {26 const base = normalizeSettings({ provider: "local", features: { summary: true, reply: true, write: true, triage: true, semantic: true }, available: { local: true, semantic: false } })27 assert.equal(aiOn(null, "summary"), false)28 assert.equal(aiOn(AI_OFF, "summary"), false)29 assert.equal(aiOn(base, "summary"), true)30 assert.equal(aiOn({ ...base, features: { ...base.features, reply: false } }, "reply"), false)31 assert.equal(aiOn(base, "semantic"), false, "pas de moteur d'indexation → pas de recherche par le sens")32 assert.equal(aiOn({ ...base, available: { ...base.available, semantic: true } }, "semantic"), true)33 assert.equal(aiOn({ ...base, provider: "anthropic" }, "summary"), false, "fournisseur externe sans consentement")34 assert.equal(aiOn({ ...base, provider: "anthropic", consent_external_at: "2026-11-20T10:00:00Z" }, "summary"), true)35 assert.equal(aiOn({ ...base, provider: "off" }, "summary"), false)36 assert.equal(aiAnyOn(AI_OFF), false)37 assert.equal(aiAnyOn(base), true)38})3940test("confirmedSettings : une copie en cache (non confirmée par le serveur) n'active aucune surface", () => {41 const s = normalizeSettings({ provider: "local", features: { summary: true } })42 assert.equal(confirmedSettings({ items: [s], loaded: true, stale: true, loading: true, error: null }), null)43 assert.equal(confirmedSettings({ items: [], loaded: false, stale: false, loading: false, error: null }), null)44 assert.equal(confirmedSettings({ items: [s], loaded: true, stale: false, loading: false, error: null }), s)45})4647test("normalizeSummary : chaînes seulement, listes plafonnées, entrées vides écartées", () => {48 const s = normalizeSummary({49 summary: " Résumé. ", decisions: ["A", 3, "", null, "B"], action_items: [{ text: "Faire", owner: null, due: " lundi " }, { text: "" }, "x", { text: { html: "<b>" } }],50 deadlines: Array.from({ length: 50 }, (_, i) => ({ text: `d${i}`, date: i ? null : "2026-12-01" })), timeline: [{ at: null, who: "Camille", what: "A écrit" }, { what: 4 }],51 provider: "local", model: "stub-model", cached: true, language: "fr",52 })53 assert.equal(s.summary, "Résumé.")54 assert.deepEqual(s.decisions, ["A", "B"])55 assert.deepEqual(s.action_items, [{ text: "Faire", owner: undefined, due: "lundi" }])56 assert.equal(s.deadlines.length, 20)57 assert.equal(s.deadlines[0].date, "2026-12-01")58 assert.deepEqual(s.timeline, [{ at: undefined, who: "Camille", what: "A écrit" }])59 assert.deepEqual([s.provider, s.model, s.cached], ["local", "stub-model", true])60 assert.equal(normalizeSummary({ summary: "x".repeat(9000) }).summary.length, 4000)61 assert.equal(summaryIsEmpty(normalizeSummary({})), true)62 assert.equal(summaryIsEmpty(normalizeSummary({ decisions: ["x"] })), false)63 assert.equal(normalizeSummary({}).cached, false)64})6566test("normalizeSummary : un contenu hostile reste une chaîne, à l'identique", () => {67 const s = normalizeSummary({ summary: HOSTILE, decisions: [HOSTILE], action_items: [{ text: HOSTILE }] })68 assert.equal(s.summary, HOSTILE)69 assert.equal(s.decisions[0], HOSTILE)70 assert.equal(s.action_items[0].text, HOSTILE)71})7273test("réponses, écriture, tri, index, usage : formes bornées", () => {74 const r = normalizeReplies({ suggestions: [{ subject: null, text: " Un " }, { text: "" }, { subject: "Re: x", text: "Deux" }, { text: "Trois" }, { text: "Quatre" }], provider: "local", model: "m", language: "fr" })75 assert.deepEqual(r.suggestions, [{ subject: undefined, text: "Un" }, { subject: "Re: x", text: "Deux" }])76 assert.equal(normalizeWrite({ text: " gardé tel quel\n", provider: "local", model: "m" }).text, " gardé tel quel\n")77 assert.deepEqual(normalizeWrite({ subjects: ["Un\nDeux", "", 3, "Trois"] }).subjects, ["Un Deux", "Trois"])78 const t = normalizeTriage({ data: [{ email_id: "a", category: "work", needs_action: true, important: true, reason: "r" }, { email_id: "b", category: "weird" }, { category: "work" }], provider: "local", model: "m" })79 assert.deepEqual([...t.items.keys()], ["a", "b"])80 assert.equal(t.items.get("b")!.category, "other")81 assert.equal(t.items.get("b")!.important, false)82 const i = normalizeIndexStatus({ enabled: false, available: false, backend: null, model: null, reason: "embedding backend disabled", mailboxes: [{ mailbox_id: "m1", indexed: 2, queued: -1, total: "9" }, {}] })83 assert.equal(i.available, false)84 assert.equal(i.reason, "embedding backend disabled")85 assert.deepEqual(i.mailboxes, [{ mailbox_id: "m1", indexed: 2, queued: 0, total: 0 }])86 const u = normalizeUsage({ data: [{ day: "2026-11-20", feature: "summary", provider: "local", model: "m", status: "ok", requests: 2, input_tokens: 200, output_tokens: 40 }, { feature: "x" }], limits: { per_minute: 30, per_day: 500, used_24h: 2 } })87 assert.equal(u.rows.length, 1)88 assert.deepEqual(u.limits, { per_minute: 30, per_day: 500, used_24h: 2 })89 assert.equal(normalizeMessage({ mailbox_id: "m", email_id: "e" }), null)90 assert.deepEqual(normalizeMessage({ mailbox_id: "m", email_id: "e", thread_id: "t", from: [{ email: "a@x", name: null }], score: 0.5, match: "both" })?.folder_roles, [])91})9293test("writeBody : seules les clés utiles à l'action partent", () => {94 assert.deepEqual(writeBody({ action: "improve", text: " Bonjour ", tone: "formal", targetLanguage: "de" }), { action: "improve", text: "Bonjour" })95 assert.deepEqual(writeBody({ action: "tone", text: "x" }), { action: "tone", text: "x", tone: "professional" })96 assert.deepEqual(writeBody({ action: "translate", text: "x", targetLanguage: "es", context: " " }), { action: "translate", text: "x", target_language: "es" })97 assert.equal((writeBody({ action: "shorten", text: "a".repeat(30_000), context: "c".repeat(9000) }).text as string).length, 20_000)98 assert.equal((writeBody({ action: "shorten", text: "a", context: "c".repeat(9000) }).context as string).length, 8000)99})100101test("aiFailure : erreur → état d'interface (409 ai_disabled, 412, 429, 502/504…)", () => {102 const f = (status: number, code: string) => aiFailure(new HttpError(status, code, code))103 assert.deepEqual(f(409, "ai_disabled"), { issue: "disabled", retry: false, resync: true })104 assert.deepEqual(f(412, "consent_required"), { issue: "consent", retry: false, resync: true })105 assert.deepEqual(f(409, "provider_unavailable"), { issue: "unavailable", retry: false, resync: true })106 assert.deepEqual(f(503, "ai_not_configured"), { issue: "unavailable", retry: false, resync: true })107 assert.deepEqual(f(409, "semantic_unavailable"), { issue: "unavailable", retry: false, resync: true })108 assert.deepEqual(f(429, "rate_limited"), { issue: "rate_limited", retry: true, resync: false })109 assert.deepEqual(f(429, "ai_rate_limited"), { issue: "rate_limited", retry: true, resync: false })110 assert.deepEqual(f(504, "ai_timeout"), { issue: "timeout", retry: true, resync: false })111 assert.deepEqual(f(502, "ai_invalid_output"), { issue: "invalid_output", retry: true, resync: false })112 assert.deepEqual(f(502, "ai_output_truncated"), { issue: "invalid_output", retry: true, resync: false })113 assert.deepEqual(f(502, "ai_unreachable"), { issue: "unavailable", retry: true, resync: false })114 assert.deepEqual(f(502, "ai_error"), { issue: "unavailable", retry: true, resync: false })115 assert.deepEqual(f(422, "ai_refused"), { issue: "refused", retry: false, resync: false })116 assert.deepEqual(f(404, "not_found"), { issue: "not_found", retry: false, resync: false })117 assert.deepEqual(f(500, "internal"), { issue: "error", retry: true, resync: false })118 assert.equal(aiFailure(new NetworkError()).issue, "offline")119 assert.equal(aiFailure(new Error("?")).issue, "error")120})121122const batch = (ids: string[], important: string[] = []): TriageBatch => ({ provider: "local", model: "stub-model", cached: false, items: new Map(ids.map((id) => [id, { category: "work" as const, needs_action: false, important: important.includes(id), reason: "" }])) })123function manualTimer() {124 let pending: (() => void) | null = null125 return { schedule: (fn: () => void) => { pending = fn; return () => { pending = null } }, fire: () => { const f = pending; pending = null; f?.() }, armed: () => !!pending }126}127128test("file de tri : regroupe après le délai, par boîte, 25 au plus, un lot à la fois, garde en mémoire", async () => {129 const calls: { mb: string; ids: string[] }[] = []130 let updates = 0131 const timer = manualTimer()132 const q = createTriageQueue({ fetch: async (mb, ids) => { calls.push({ mb, ids }); return batch(ids, ["m1-0"]) }, onUpdate: () => updates++, schedule: timer.schedule })133 for (let i = 0; i < 30; i++) assert.equal(q.want("m1", `m1-${i}`), undefined)134 assert.equal(q.want("m2", "m2-0"), undefined)135 assert.equal(q.want("m1", "m1-0"), undefined, "déjà en attente : pas de doublon")136 assert.equal(calls.length, 0, "rien ne part avant le délai")137 assert.equal(timer.armed(), true)138 timer.fire()139 await q.flush()140 assert.deepEqual(calls.map((c) => [c.mb, c.ids.length]), [["m1", 25], ["m1", 5], ["m2", 1]])141 assert.equal(new Set(calls.flatMap((c) => c.ids)).size, 31)142 assert.equal(updates, 3)143 assert.equal(q.want("m1", "m1-0")!.important, true)144 assert.equal(q.peek("m1-7")!.category, "work")145 assert.deepEqual(q.by(), { provider: "local", model: "stub-model", cached: false })146 assert.equal(timer.armed(), false, "un résultat connu ne relance rien")147 await q.flush()148 assert.equal(calls.length, 3)149})150151test("file de tri : échec silencieux, pas de nouvelle demande en boucle ; clear() remet à zéro et ignore les réponses tardives", async () => {152 let n = 0153 let updates = 0154 const timer = manualTimer()155 const q = createTriageQueue({ fetch: async (_mb, ids) => { n++; if (n === 1) throw new Error("down"); return batch(ids.filter((id) => id !== "absent")) }, onUpdate: () => updates++, schedule: timer.schedule })156 q.want("m", "a")157 await q.flush()158 assert.equal(q.want("m", "a"), undefined)159 assert.equal(timer.armed(), false, "un message en échec n'est pas redemandé")160 assert.equal(updates, 0)161 q.want("m", "b"); q.want("m", "absent")162 await q.flush()163 assert.equal(q.peek("b")!.category, "work")164 assert.equal(q.want("m", "absent"), undefined)165 assert.equal(timer.armed(), false, "un message que le serveur n'a pas rendu n'est pas redemandé")166 q.clear()167 assert.equal(q.peek("b"), undefined)168 assert.equal(q.by(), null)169 // réponse tardive après clear()170 let release: (v: TriageBatch) => void = () => {}171 const q2 = createTriageQueue({ fetch: () => new Promise<TriageBatch>((r) => { release = r }), onUpdate: () => updates++, schedule: timer.schedule })172 q2.want("m", "z")173 const p = q2.flush()174 q2.clear()175 release(batch(["z"]))176 await p177 assert.equal(q2.peek("z"), undefined)178 assert.equal(updates, 1)179 assert.equal(q.want("", "sans-boite"), undefined)180})181182test("textToDraftHtml : le texte du modèle reste du texte (aucune balise créée)", () => {183 const doc = new JSDOM("").window.document184 const html = textToDraftHtml(`Bonjour,\n\n${HOSTILE}\nMerci & à bientôt`, doc)185 assert.ok(!/<img|<script|<a\b/i.test(html), html)186 assert.ok(html.includes("<img src=x onerror="))187 assert.ok(html.includes("<script>"))188 assert.ok(html.includes("Merci & à bientôt"))189 // relu par un analyseur HTML : aucun élément actif, le texte d'origine intact190 const back = new JSDOM(`<body>${html}</body>`).window.document191 assert.equal(back.querySelectorAll("img, script, a, iframe, style, [onerror]").length, 0)192 assert.deepEqual([...back.body.children].map((d) => d.tagName), ["DIV", "DIV", "DIV", "DIV"])193 assert.equal(back.body.children[2].textContent, HOSTILE)194 assert.equal(back.body.children[1].innerHTML, "<br>")195})196197test("insertSuggestion : au-dessus de la signature et du message cité, texte brut aligné", () => {198 const doc = new JSDOM("").window.document199 const draft = { html: '<div><br></div><blockquote class="spm-quote">cité</blockquote>', text: "\n\nLe … a écrit :\n> cité\n" }200 const out = insertSuggestion(draft, " Bonjour,\r\n<b>oui</b> ", doc)201 assert.equal(out.html, `<div>Bonjour,</div><div><b>oui</b></div>${draft.html}`)202 assert.equal(out.text, `Bonjour,\n<b>oui</b>\n${draft.text}`)203 assert.equal(insertSuggestion({ html: "", text: "sig" }, "A", doc).text, "A\n\nsig")204})205206test("reminderDue : toujours dans le futur, à 9 h locale", () => {207 const fri = new Date(2026, 10, 20, 15, 30) // vendredi 20 novembre 2026208 assert.deepEqual([reminderDue("tomorrow", fri).getDate(), reminderDue("tomorrow", fri).getHours()], [21, 9])209 assert.equal(reminderDue("in3days", fri).getDate(), 23)210 const mon = reminderDue("nextWeek", fri)211 assert.deepEqual([mon.getDay(), mon.getDate()], [1, 23])212 const fromMonday = reminderDue("nextWeek", new Date(2026, 10, 23, 8, 0))213 assert.deepEqual([fromMonday.getDay(), fromMonday.getDate()], [1, 30], "un lundi : le lundi suivant, jamais le jour même")214 for (const p of ["tomorrow", "in3days", "nextWeek"] as const) assert.ok(reminderDue(p, fri).getTime() > fri.getTime())215})216