Repository Public
1// SP Mail Next — recherche unifiée, index des pièces jointes et ZIP, sur de vrais messages échangés entre boîtes de recette (stg.spboucher.ai) :2// opérateurs, négation, OR, dates, dossiers, étiquette posée par JMAP, deux boîtes fusionnées avec un curseur stable, fils regroupés, cloisonnement.3import assert from "node:assert/strict"4import { spawnSync } from "node:child_process"5import crypto from "node:crypto"6import fs from "node:fs"7import os from "node:os"8import path from "node:path"9import { after, before, test } from "node:test"10import { ApiError, ApiKey, Client, RUN, cli, sleep, sql, startServer, stopServer, tokenOf, until } from "../harness"11import { mkKey, mkMailbox, purgeAll, sendAndWait, setupAdmin, type Box } from "./v1-helpers"1213let admin: Client, member: Client14let P: Box, Q: Box, X: Box15let kp: ApiKey, kq: ApiKey, kx: ApiKey16const ALL = ["mail.send", "mail.read", "mail.search", "mail.modify", "mail.delete", "mail.drafts", "mail.attachments.read", "mail.attachments.write"]17const PDF = crypto.randomBytes(30_000)18const NOTES = Buffer.from("Notes d'été : à relire.\n".repeat(40), "utf8")19const PNG = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64")2021async function rejects(p: Promise<unknown>, status: number, code?: string) {22 await assert.rejects(p, (e: unknown) => e instanceof ApiError && e.status === status && (!code || e.code === code), `attendu ${status} ${code ?? ""}`)23}24const search = (c: Client, q: string, extra = "") => c.call("GET", `/api/next/search?q=${encodeURIComponent(q)}${extra}`)25const subjects = async (q: string, extra = "") => ((await search(admin, q, extra)).data as any[]).map((m) => m.subject).sort()26const upload = async (k: ApiKey, name: string, bytes: Buffer, type: string) => (await (await k.raw("POST", `/files?filename=${encodeURIComponent(name)}`, new Uint8Array(bytes), { "content-type": type })).json()).id as string27const v1Id = async (k: ApiKey, subject: string, folder = "inbox") => until(async () => (await k.call("GET", `/messages?folder=${folder}&limit=100`)).data.find((m: any) => m.subject === subject)?.id as string | undefined, `message « ${subject} »`)28const acctOf = async (c: Client, b: Box) => (await c.call("GET", `/api/jmap/${b.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"] as string2930before(async () => {31 await startServer()32 admin = await setupAdmin()33 member = new Client("web")34 await member.enroll(tokenOf(await cli("invite")), "membre", "Membre")35 const memberId = (await sql`select id from users where handle = 'membre'`)[0].id36 ;[P, Q, X] = await Promise.all([mkMailbox(admin, "sp"), mkMailbox(admin, "sq"), mkMailbox(admin, "sx", memberId)])37 kp = await mkKey(admin, { scopes: ALL, addresses: [P.addressId] })38 kq = await mkKey(admin, { scopes: ALL, addresses: [Q.addressId] })39 kx = await mkKey(admin, { scopes: ALL, addresses: [X.addressId] })40 const [pdf, notes, logo, photo] = await Promise.all([upload(kx, "rapport annuel.pdf", PDF, "application/pdf"), upload(kx, "notes été.txt", NOTES, "text/plain"), upload(kx, "logo.png", PNG, "image/png"), upload(kx, "photo.png", PNG, "image/png")])41 await Promise.all([42 sendAndWait(kx, { from: X.address, to: [P.address], subject: "Devis toiture alpha", text: "Le montant du devis est de 4200 dollars. zinzolin" }),43 sendAndWait(kx, { from: X.address, to: [P.address], subject: "Facture mars", text: "Voir les documents joints.", html: '<p>Voir les documents joints. <img src="cid:logo"></p>', attachments: [{ file_id: pdf }, { file_id: notes }, { file_id: logo, inline: true, cid: "logo" }] }),44 sendAndWait(kq, { from: Q.address, to: [P.address], subject: "Réunion budget", text: "Ordre du jour de la réunion." }),45 sendAndWait(kx, { from: X.address, to: [Q.address], subject: "Devis fenêtres", text: "Un second devis. zinzolin" }),46 sendAndWait(kx, { from: X.address, to: [Q.address], subject: "Photos chantier", text: "Une photo.", attachments: [{ file_id: photo }] }),47 sendAndWait(kp, { from: P.address, to: [X.address], subject: "Réponse devis", text: "Bien reçu, merci." }),48 ...[1, 2, 3, 4, 5, 6, 7].map((n) => sendAndWait(kx, { from: X.address, to: [n % 2 ? P.address : Q.address], subject: `Série ${n}`, text: `Message de série numéro ${n}.` })),49 ])50 // 13 messages envoyés ; « Réunion budget » existe deux fois chez l'administrateur (Envoyés de Q, Réception de P) : 13 + 1 - 0 = 14 entrées visibles pour lui moins celles de X51 await until(async () => (await search(admin, "in:all", "&limit=100")).data.length >= 14, "indexation des 14 messages de l'administrateur", 60_000)52})53after(async () => {54 await purgeAll(admin)55 await stopServer()56})5758test("opérateurs sur de vrais messages : from, to, subject, body, has, larger/smaller, filename, expression exacte", async () => {59 const r = await search(admin, "subject:toiture")60 assert.equal(r.data.length, 1)61 const m = r.data[0]62 assert.deepEqual([m.mailbox_id, m.subject, m.from, m.to.map((t: any) => t.email), m.has_attachment, m.folder_roles, m.keywords.includes("$seen")], [P.id, "Devis toiture alpha", [{ email: X.address, name: "Essai sx" }], [P.address], false, ["inbox"], false])63 assert.ok(m.email_id && m.thread_id && m.size > 0 && m.preview.includes("4200") && !Number.isNaN(Date.parse(m.received_at)) && m.mailbox_ids.length === 1)64 assert.deepEqual(r.parsed.errors, [])65 assert.deepEqual(r.parsed.terms.map((t: any) => [t.op, t.value]), [["subject", "toiture"]])66 assert.equal(r.next_cursor, null)67 assert.deepEqual(await subjects(`from:${X.address} devis`), ["Devis fenêtres", "Devis toiture alpha"])68 assert.deepEqual(await subjects(`de:${Q.address}`), ["Réunion budget", "Réunion budget"], "copie « Envoyés » de Q et réception de P")69 assert.deepEqual(await subjects(`to:${Q.address} devis`), ["Devis fenêtres"])70 assert.deepEqual(await subjects(`to:${X.address}`), ["Réponse devis"])71 assert.deepEqual(await subjects("body:zinzolin"), ["Devis fenêtres", "Devis toiture alpha"])72 assert.deepEqual(await subjects("zinzolin sujet:fenêtres"), ["Devis fenêtres"])73 assert.deepEqual(await subjects('"montant du devis"'), ["Devis toiture alpha"])74 assert.deepEqual(await subjects("has:attachment"), ["Facture mars", "Photos chantier"])75 assert.deepEqual(await subjects("avec:pj subject:facture"), ["Facture mars"])76 assert.deepEqual(await subjects("subject:devis -has:attachment"), ["Devis fenêtres", "Devis toiture alpha", "Réponse devis"])77 assert.deepEqual(await subjects("larger:20k"), ["Facture mars"])78 assert.deepEqual(await subjects("smaller:20k has:attachment"), ["Photos chantier"])79 assert.deepEqual(await subjects("filename:rapport"), ["Facture mars"])80 assert.deepEqual(await subjects("filename:ÉTÉ"), ["Facture mars"])81 assert.deepEqual(await subjects("filename:photo"), ["Photos chantier"])82 assert.deepEqual(await subjects("filename:introuvable"), [])83 assert.deepEqual(await subjects("has:attachment -filename:photo"), ["Facture mars"])84})8586test("négation, OR, dates", async () => {87 assert.deepEqual(await subjects("subject:devis -toiture"), ["Devis fenêtres", "Réponse devis"])88 assert.deepEqual(await subjects("subject:devis -subject:toiture -subject:fenêtres"), ["Réponse devis"])89 assert.deepEqual(await subjects(`subject:devis -from:${X.address}`), ["Réponse devis"])90 assert.deepEqual(await subjects("subject:toiture OR subject:fenêtres"), ["Devis fenêtres", "Devis toiture alpha"])91 assert.deepEqual(await subjects("subject:toiture OR subject:budget in:inbox"), ["Devis toiture alpha", "Réunion budget"])92 assert.deepEqual(await subjects("subject:toiture OR subject:fenêtres OR subject:facture -has:attachment"), ["Devis fenêtres", "Devis toiture alpha"])93 assert.deepEqual(await subjects("subject:devis after:today"), ["Devis fenêtres", "Devis toiture alpha", "Réponse devis"])94 assert.deepEqual(await subjects("subject:devis after:1d"), ["Devis fenêtres", "Devis toiture alpha", "Réponse devis"])95 assert.deepEqual(await subjects("subject:devis before:1d"), [])96 assert.deepEqual(await subjects("subject:devis before:yesterday"), [])97 assert.deepEqual(await subjects("subject:devis avant:2020-01-01"), [])98 assert.deepEqual(await subjects("subject:devis après:2020-01-01 before:today"), ["Devis fenêtres", "Devis toiture alpha", "Réponse devis"], "before inclut la journée indiquée")99 assert.deepEqual(await subjects("subject:devis -after:2020-01-01"), [])100 // une valeur invalide est signalée et ignorée ; la requête répond quand même101 const bad = await search(admin, "subject:toiture before:jamais is:violet")102 assert.deepEqual(bad.data.map((m: any) => m.subject), ["Devis toiture alpha"])103 assert.deepEqual(bad.parsed.errors.map((e: any) => [e.token, e.code]), [["before:jamais", "invalid_date"], ["is:violet", "invalid_value"]])104})105106test("in:, is:, label: (mot-clé posé par JMAP), corbeille exclue par défaut", async () => {107 assert.deepEqual(await subjects("in:inbox subject:devis"), ["Devis fenêtres", "Devis toiture alpha"])108 assert.deepEqual(await subjects("in:sent"), ["Réponse devis", "Réunion budget"])109 assert.deepEqual(await subjects("dans:envoyés subject:devis"), ["Réponse devis"])110 assert.deepEqual(await subjects("subject:devis -in:sent"), ["Devis fenêtres", "Devis toiture alpha"])111 const none = await search(admin, "in:nulle-part devis")112 assert.deepEqual([none.data, none.parsed.errors.map((e: any) => e.code)], [[], ["unknown_folder"]])113 // lu / non lu / suivi : états posés par l'API v1, lus par la recherche114 const toiture = await v1Id(kp, "Devis toiture alpha")115 assert.deepEqual(await subjects("is:unread subject:toiture"), ["Devis toiture alpha"])116 await kp.call("PATCH", `/messages/${toiture}`, { unread: false, starred: true })117 assert.deepEqual(await subjects("is:unread subject:toiture"), [])118 assert.deepEqual(await subjects("est:lu subject:toiture"), ["Devis toiture alpha"])119 assert.deepEqual(await subjects("is:starred"), ["Devis toiture alpha"])120 assert.deepEqual(await subjects("subject:devis -is:starred in:inbox"), ["Devis fenêtres"])121 // étiquette : créée par l'API, posée sur le message par du JMAP standard, retrouvée par son NOM122 const label = await admin.call("POST", "/api/next/labels", { name: "Clients à relancer" })123 assert.deepEqual(await subjects('label:"clients à relancer"'), [])124 const fen = (await search(admin, "subject:fenêtres")).data[0]125 const acctQ = await acctOf(admin, Q)126 const set = await admin.jmap(Q.id, [["Email/set", { accountId: acctQ, update: { [fen.email_id]: { [`keywords/${label.keyword}`]: true } } }, "u"]])127 assert.ok(set[0][1].updated && fen.email_id in set[0][1].updated, JSON.stringify(set))128 const hit = await search(admin, 'label:"Clients à relancer"')129 assert.deepEqual(hit.data.map((m: any) => [m.subject, m.mailbox_id, m.keywords.includes(label.keyword)]), [["Devis fenêtres", Q.id, true]])130 assert.deepEqual(await subjects('étiquette:"CLIENTS A RELANCER" subject:devis'), ["Devis fenêtres"])131 assert.deepEqual(await subjects('subject:devis -label:"clients à relancer" in:inbox'), ["Devis toiture alpha"])132 assert.deepEqual(await subjects(`label:${label.keyword}`), ["Devis fenêtres"])133 await admin.call("PATCH", `/api/next/labels/${label.id}`, { name: "Relances" })134 assert.deepEqual(await subjects("label:relances"), ["Devis fenêtres"], "renommer l'étiquette ne touche pas le message")135 const unknown = await search(admin, 'label:"clients à relancer"')136 assert.deepEqual([unknown.data, unknown.parsed.errors.map((e: any) => [e.token, e.code])], [[], [['label:"clients à relancer"', "unknown_label"]]])137 assert.deepEqual((await search(member, "label:relances")).parsed.errors.map((e: any) => e.code), ["unknown_label"], "les étiquettes sont propres à chaque utilisateur")138 // corbeille : hors de la portée par défaut, visible avec in:trash ou in:all139 assert.deepEqual(await subjects("subject:budget"), ["Réunion budget", "Réunion budget"])140 await kp.call("DELETE", `/messages/${await v1Id(kp, "Réunion budget")}`, {})141 await until(async () => (await subjects("subject:budget")).length === 1, "message à la corbeille exclu")142 assert.deepEqual((await search(admin, "subject:budget")).data.map((m: any) => m.folder_roles), [["sent"]])143 assert.deepEqual((await search(admin, "subject:budget in:trash")).data.map((m: any) => [m.mailbox_id, m.folder_roles]), [[P.id, ["trash"]]])144 assert.deepEqual(await subjects("subject:budget in:all"), ["Réunion budget", "Réunion budget"])145 assert.deepEqual(await subjects("subject:budget dans:corbeille OR in:sent"), ["Réunion budget", "Réunion budget"])146})147148test("deux boîtes fusionnées par date : pagination sans doublon ni trou, curseur stable quand du courrier arrive", async () => {149 const all = (await search(admin, "subject:Série", "&limit=50")).data as any[]150 assert.deepEqual(all.map((m) => m.subject).sort(), [1, 2, 3, 4, 5, 6, 7].map((n) => `Série ${n}`))151 assert.deepEqual([...new Set(all.map((m) => m.mailbox_id))].sort(), [P.id, Q.id].sort())152 assert.deepEqual(all.map((m) => m.received_at), [...all.map((m) => m.received_at)].sort().reverse(), "du plus récent au plus ancien")153 const p1 = await search(admin, "subject:Série", "&limit=3")154 assert.equal(p1.data.length, 3)155 assert.ok(p1.next_cursor)156 // un nouveau message arrive entre deux pages : les pages suivantes ne bougent pas157 await sendAndWait(kx, { from: X.address, to: [Q.address], subject: "Série 8", text: "Arrivé pendant la pagination." })158 await until(async () => (await subjects("subject:Série", "&limit=50")).length === 8, "indexation de Série 8")159 const p2 = await search(admin, "subject:Série", `&limit=3&cursor=${p1.next_cursor}`)160 const p3 = await search(admin, "subject:Série", `&limit=3&cursor=${p2.next_cursor}`)161 assert.deepEqual([p2.data.length, p3.data.length, p3.next_cursor], [3, 1, null])162 const key = (m: any) => `${m.mailbox_id}:${m.email_id}`163 assert.deepEqual([...p1.data, ...p2.data, ...p3.data].map(key), all.map(key), "les trois pages redonnent exactement la liste d'origine, dans l'ordre")164 assert.deepEqual((await search(admin, "subject:Série", `&limit=3&cursor=${p1.next_cursor}`)).data.map(key), p2.data.map(key), "même curseur, même page")165 // le curseur appartient à sa requête166 await rejects(search(admin, "subject:devis", `&limit=3&cursor=${p1.next_cursor}`), 400, "invalid_cursor")167 await rejects(search(admin, "subject:Série", `&limit=3&mailboxes=${P.id}&cursor=${p1.next_cursor}`), 400, "invalid_cursor")168 await rejects(search(admin, "subject:Série", "&cursor=n-importe-quoi"), 400, "invalid_cursor")169 // choix des boîtes ; celle d'un autre utilisateur est indiscernable d'une boîte inexistante170 assert.deepEqual(await subjects("subject:Série", `&mailboxes=${P.id}`), ["Série 1", "Série 3", "Série 5", "Série 7"])171 assert.deepEqual(await subjects("subject:Série", `&mailboxes=${Q.id},${P.id}&limit=50`), [1, 2, 3, 4, 5, 6, 7, 8].map((n) => `Série ${n}`))172 assert.deepEqual(await subjects("subject:Série", "&mailboxes=all&limit=50"), [1, 2, 3, 4, 5, 6, 7, 8].map((n) => `Série ${n}`))173 await rejects(search(admin, "subject:Série", `&mailboxes=${X.id}`), 404, "not_found")174 await rejects(search(admin, "subject:Série", `&mailboxes=${P.id},${crypto.randomUUID()}`), 404, "not_found")175 await rejects(search(admin, "x", "&limit=0"), 400, "invalid_request")176 // l'autre utilisateur ne cherche que dans ses boîtes (ici : les copies « Envoyés » de X)177 const theirs = (await search(member, "subject:Série", "&limit=50")).data as any[]178 assert.equal(theirs.length, 8)179 assert.ok(theirs.every((m) => m.mailbox_id === X.id && m.folder_roles.includes("sent")))180 assert.deepEqual((await search(member, "subject:budget in:all")).data, [])181})182183test("fils regroupés (threads=1) et pagination par fil", async () => {184 // P répond au devis, X répond à son tour : le fil compte trois messages chez P185 const rep = await kp.call("POST", `/messages/${await v1Id(kp, "Devis toiture alpha")}/reply`, { text: "Pouvez-vous préciser le délai ?" })186 assert.equal(rep.status, "sent")187 await kx.call("POST", `/messages/${await v1Id(kx, "Re: Devis toiture alpha")}/reply`, { text: "Trois semaines." })188 await until(async () => (await subjects("subject:toiture", `&mailboxes=${P.id}`)).length === 3, "trois messages dans le fil")189 const flat = (await search(admin, "subject:toiture", `&mailboxes=${P.id}`)).data as any[]190 assert.equal(new Set(flat.map((m) => m.thread_id)).size, 1)191 const grouped = (await search(admin, "subject:toiture", `&mailboxes=${P.id}&threads=1`)).data as any[]192 assert.equal(grouped.length, 1)193 assert.ok(flat.some((m) => m.email_id === grouped[0].email_id))194 assert.equal(grouped[0].received_at, flat[0].received_at, "le fil est représenté par son message le plus récent")195 // un fil par page : aucun fil ne revient sur une page suivante196 const seen: string[] = []197 let cursor = ""198 for (let i = 0; i < 10; i++) {199 const page = await search(admin, "subject:devis", `&threads=1&limit=1${cursor ? `&cursor=${cursor}` : ""}`)200 seen.push(...page.data.map((m: any) => `${m.mailbox_id}:${m.thread_id}`))201 if (!page.next_cursor) break202 cursor = page.next_cursor203 }204 assert.equal(new Set(seen).size, seen.length, "aucun fil en double")205 assert.equal(seen.length, new Set(((await search(admin, "subject:devis", "&limit=100")).data as any[]).map((m) => `${m.mailbox_id}:${m.thread_id}`)).size)206})207208test("POST /search/parse : forme analysée, erreurs par jeton, jamais d'échec sur une entrée invalide", async () => {209 const p = await admin.call("POST", "/api/next/search/parse", { q: 'from:alice OR de:bob -"mot à mot" label:Relances label:inconnue before:2026-13-45 larger:2m', tz: "America/Toronto" })210 assert.deepEqual(p.terms.map((t: any) => [t.op, t.value, t.negated, t.group]), [["from", "alice", false, 0], ["from", "bob", false, 0], ["text", "mot à mot", true, 1], ["label", "Relances", false, 2], ["label", "inconnue", false, 3], ["larger", "2m", false, 4]])211 assert.equal(p.terms[5].bytes, 2 * 1024 * 1024)212 assert.deepEqual(p.errors.map((e: any) => [e.token, e.code]), [["before:2026-13-45", "invalid_date"], ["label:inconnue", "unknown_label"]])213 assert.ok(p.errors.every((e: any) => typeof e.start === "number" && typeof e.end === "number" && typeof e.message === "string"))214 assert.equal(p.filters.operator, "AND")215 assert.deepEqual(p.filters.conditions[0], { operator: "OR", conditions: [{ from: "alice" }, { from: "bob" }] })216 for (const body of [{}, { q: 42 }, { q: null }, { q: ["a"] }, { q: "\u0000\"" }, { q: "x".repeat(5000) }, []]) {217 const r = await admin.raw("POST", "/api/next/search/parse", body)218 assert.equal(r.status, 200, JSON.stringify(body).slice(0, 40))219 const j = await r.json()220 assert.ok(Array.isArray(j.terms) && Array.isArray(j.errors))221 }222 assert.equal((await new Client("web").raw("POST", "/api/next/search/parse", { q: "x" })).status, 401)223})224225test("index des pièces jointes : familles, filtres, pagination, téléchargement par la passerelle", async () => {226 const all = (await admin.call("GET", "/api/next/attachments")).data as any[]227 assert.deepEqual(all.map((a) => a.name).sort(), ["notes été.txt", "photo.png", "rapport annuel.pdf"], "l'image incorporée (cid) n'est pas une pièce jointe")228 const pdf = all.find((a) => a.name === "rapport annuel.pdf"), txt = all.find((a) => a.name === "notes été.txt"), png = all.find((a) => a.name === "photo.png")229 assert.deepEqual([pdf.kind, pdf.type, pdf.size, pdf.mailbox_id, pdf.subject, pdf.from, pdf.inline_ok], ["pdf", "application/pdf", PDF.length, P.id, "Facture mars", [{ email: X.address, name: "Essai sx" }], false])230 assert.deepEqual([txt.kind, txt.size, txt.inline_ok, png.kind, png.mailbox_id, png.inline_ok], ["document", NOTES.length, false, "image", Q.id, true])231 assert.ok(pdf.email_id && pdf.thread_id && pdf.blob_id && !Number.isNaN(Date.parse(pdf.received_at)))232 const names = async (qs: string) => ((await admin.call("GET", `/api/next/attachments?${qs}`)).data as any[]).map((a) => a.name).sort()233 assert.deepEqual(await names("kind=pdf"), ["rapport annuel.pdf"])234 assert.deepEqual(await names("kind=image,document"), ["notes été.txt", "photo.png"])235 assert.deepEqual(await names("kind=video"), [])236 assert.deepEqual(await names("min_size=20000"), ["rapport annuel.pdf"])237 assert.deepEqual(await names("max_size=200"), ["photo.png"])238 assert.deepEqual(await names(`q=${encodeURIComponent("ÉTÉ")}`), ["notes été.txt"])239 assert.deepEqual(await names(`from=${encodeURIComponent(X.address)}&mailboxes=${Q.id}`), ["photo.png"])240 assert.deepEqual(await names(`mailboxes=${P.id}`), ["notes été.txt", "rapport annuel.pdf"])241 assert.deepEqual(await names("after=today"), ["notes été.txt", "photo.png", "rapport annuel.pdf"])242 assert.deepEqual(await names("before=2020-01-01"), [])243 await rejects(admin.call("GET", "/api/next/attachments?kind=virus"), 400, "invalid_request")244 await rejects(admin.call("GET", "/api/next/attachments?after=bientot"), 400, "invalid_request")245 await rejects(admin.call("GET", `/api/next/attachments?mailboxes=${X.id}`), 404, "not_found")246 // pagination à l'unité : chaque pièce une fois, y compris les deux pièces d'un même message247 const got: string[] = []248 let cursor = ""249 for (let i = 0; i < 10; i++) {250 const page = await admin.call("GET", `/api/next/attachments?limit=1${cursor ? `&cursor=${cursor}` : ""}`)251 got.push(...page.data.map((a: any) => a.blob_id))252 if (!page.next_cursor) break253 cursor = page.next_cursor254 }255 assert.deepEqual(got, all.map((a) => a.blob_id))256 // l'URL rendue est celle de la passerelle existante : octets identiques, jamais interprétés ; affichage en ligne pour les seules images permises257 const dl = await admin.raw("GET", pdf.download_url)258 assert.equal(dl.status, 200)259 assert.match(dl.headers.get("content-disposition")!, /^attachment/)260 assert.ok(Buffer.from(await dl.arrayBuffer()).equals(PDF))261 const img = await admin.raw("GET", `${png.download_url}&inline=1`)262 assert.match(img.headers.get("content-disposition")!, /^inline/)263 assert.ok(Buffer.from(await img.arrayBuffer()).equals(PNG))264 assert.equal((await member.raw("GET", pdf.download_url)).status, 404, "l'URL ne donne rien à un autre utilisateur")265 // le membre ne voit que les pièces de ses boîtes (ses copies « Envoyés »)266 const theirs = (await member.call("GET", "/api/next/attachments")).data as any[]267 assert.ok(theirs.length >= 3 && theirs.every((a) => a.mailbox_id === X.id))268})269270test("ZIP en flux : contenu identique octet pour octet, noms dédoublonnés, appartenance revérifiée", async () => {271 const all = (await admin.call("GET", "/api/next/attachments")).data as any[]272 const item = (name: string, as?: string) => { const a = all.find((x) => x.name === name); return { mailbox_id: a.mailbox_id, email_id: a.email_id, blob_id: a.blob_id, ...(as ? { name: as } : {}) } }273 const r = await admin.raw("POST", "/api/next/attachments/zip", { items: [item("rapport annuel.pdf"), item("notes été.txt"), item("photo.png"), item("rapport annuel.pdf"), item("photo.png", "../../etc/passwd")], filename: "Dossier été" })274 assert.equal(r.status, 200)275 assert.equal(r.headers.get("content-type"), "application/zip")276 assert.match(r.headers.get("content-disposition")!, /^attachment; filename\*=UTF-8''Dossier%20%C3%A9t%C3%A9\.zip$/)277 const dir = fs.mkdtempSync(path.join(os.tmpdir(), "spmail-zip-"))278 const file = path.join(dir, "a.zip")279 fs.writeFileSync(file, Buffer.from(await r.arrayBuffer()))280 // deux lecteurs indépendants : `unzip -t` vérifie les CRC, zipfile (Python) extrait les entrées281 const t = spawnSync("unzip", ["-t", file], { encoding: "utf8" })282 assert.equal(t.status, 0, t.stdout + t.stderr)283 const out = path.join(dir, "out")284 const x = spawnSync("python3", ["-I", "-c", "import sys, zipfile, json\nz = zipfile.ZipFile(sys.argv[1])\nassert z.testzip() is None\nz.extractall(sys.argv[2])\nprint(json.dumps(z.namelist()))", file, out], { encoding: "utf8" })285 assert.equal(x.status, 0, x.stderr)286 assert.deepEqual(JSON.parse(x.stdout), ["rapport annuel.pdf", "notes été.txt", "photo.png", "rapport annuel (2).pdf", "_.._etc_passwd"])287 assert.ok(fs.readFileSync(path.join(out, "rapport annuel.pdf")).equals(PDF))288 assert.ok(fs.readFileSync(path.join(out, "rapport annuel (2).pdf")).equals(PDF))289 assert.ok(fs.readFileSync(path.join(out, "notes été.txt")).equals(NOTES))290 assert.ok(fs.readFileSync(path.join(out, "photo.png")).equals(PNG))291 assert.ok(fs.readFileSync(path.join(out, "_.._etc_passwd")).equals(PNG))292 assert.deepEqual(fs.readdirSync(out).length, 5, "rien n'a été écrit hors du dossier")293 fs.rmSync(dir, { recursive: true, force: true })294 // refus : blob qui n'est pas une pièce jointe de CE message, boîte d'autrui, liste vide ou trop longue295 const pdf = item("rapport annuel.pdf"), png = item("photo.png")296 const zip = (c: Client, items: unknown[]) => c.call("POST", "/api/next/attachments/zip", { items })297 await rejects(zip(admin, [{ ...pdf, blob_id: png.blob_id }]), 404, "not_found")298 await rejects(zip(admin, [{ ...png, mailbox_id: P.id }]), 404, "not_found")299 await rejects(zip(admin, [{ ...pdf, email_id: "inexistant" }]), 404, "not_found")300 await rejects(zip(member, [pdf]), 404, "not_found")301 const theirs = ((await member.call("GET", "/api/next/attachments")).data as any[])[0]302 await rejects(zip(admin, [{ mailbox_id: theirs.mailbox_id, email_id: theirs.email_id, blob_id: theirs.blob_id }]), 404, "not_found")303 await rejects(zip(admin, []), 400, "invalid_request")304 await rejects(zip(admin, Array.from({ length: 51 }, () => pdf)), 400, "invalid_request")305 await rejects(zip(admin, [{ ...pdf, blob_id: "../x" }]), 400, "invalid_request")306})307308test("tableau de bord : forme complète, compteurs réels, cache court, cloisonnement", async () => {309 const d = await admin.call("GET", "/api/next/dashboard?fresh=1")310 assert.deepEqual(Object.keys(d).sort(), ["attention", "delivery_issues", "generated_at", "inbox", "partial", "pending_replies", "recent_attachments", "scheduled", "storage", "sync", "top_contacts"])311 assert.deepEqual(d.partial, [], "aucun bloc en panne")312 assert.deepEqual(d.inbox.map((i: any) => [i.mailbox_id, i.address]).sort(), [[P.id, P.address], [Q.id, Q.address]].sort())313 const inboxP = d.inbox.find((i: any) => i.mailbox_id === P.id)314 assert.ok(inboxP.total >= 6 && inboxP.unread >= 5 && inboxP.unread < inboxP.total, JSON.stringify(inboxP))315 assert.deepEqual(Object.keys(d.attention).sort(), ["flagged", "reminders_due", "snoozed_today", "unanswered"])316 assert.equal(d.attention.flagged, 1, "« Devis toiture alpha » est suivi")317 assert.deepEqual([d.attention.reminders_due, d.attention.snoozed_today], [0, 0])318 // en attente de réponse : dernier message d'autrui, sans réponse, non lu ou suivi — X a eu le dernier mot dans le fil « toiture »319 assert.ok(d.pending_replies.length > 0 && d.pending_replies.length <= 10 && d.attention.unanswered >= d.pending_replies.length)320 assert.ok(d.pending_replies.every((m: any) => m.from[0].email === X.address && m.folder_roles.includes("inbox")), "jamais un message de l'utilisateur lui-même")321 assert.ok(d.pending_replies.some((m: any) => m.subject === "Re: Devis toiture alpha"))322 assert.ok(!d.pending_replies.some((m: any) => m.subject === "Devis toiture alpha"), "le message auquel on a répondu n'attend plus")323 assert.deepEqual(d.recent_attachments.map((a: any) => a.name).sort(), ["notes été.txt", "photo.png", "rapport annuel.pdf"])324 assert.ok(d.top_contacts.some((c: any) => c.emails[0].email === X.address && c.stats.received >= 5), "correspondant moissonné")325 assert.deepEqual(d.storage.map((s: any) => s.mailbox_id).sort(), [P.id, Q.id].sort())326 assert.ok(d.storage.every((s: any) => (s.used_bytes === null || s.used_bytes >= 0) && s.quota_bytes === null))327 assert.deepEqual([d.scheduled, d.delivery_issues], [[], []])328 assert.deepEqual([d.sync.mail_server, d.sync.push], ["reachable", "disabled"])329 assert.ok(typeof d.sync.watcher_lag_ms === "number" && d.sync.watcher_lag_ms >= 0)330 // un envoi programmé de l'utilisateur apparaît ; le cache court sert la même réponse sans `fresh`331 const cached = await admin.call("GET", "/api/next/dashboard")332 assert.equal(cached.generated_at, d.generated_at)333 const later = await admin.raw("POST", "/api/v1/messages/send", { from: P.address, to: [X.address], subject: "Programmé pour le tableau de bord", text: "x", send_at: new Date(Date.now() + 3600_000).toISOString() })334 assert.equal(later.status, 202)335 const id = (await later.json()).id336 assert.equal((await admin.call("GET", "/api/next/dashboard")).scheduled.length, 0, "réponse en cache (15 s)")337 const d2 = await admin.call("GET", "/api/next/dashboard?fresh=1")338 assert.deepEqual(d2.scheduled.map((o: any) => [o.id, o.status, o.from, o.subject]), [[id, "scheduled", P.address, "Programmé pour le tableau de bord"]], "sujet lu dans le brouillon conservé")339 assert.equal((await admin.raw("DELETE", `/api/v1/messages/scheduled/${id}`)).status, 200)340 // l'autre utilisateur a son propre tableau341 const m = await member.call("GET", "/api/next/dashboard?fresh=1")342 assert.deepEqual(m.inbox.map((i: any) => i.mailbox_id), [X.id])343 assert.deepEqual([m.scheduled, m.storage.map((s: any) => s.mailbox_id)], [[], [X.id]])344 assert.ok(m.recent_attachments.every((a: any) => a.mailbox_id === X.id))345 assert.equal((await new Client("web").raw("GET", "/api/next/dashboard")).status, 401)346})347348test("tableau de bord : un bloc en panne est nommé dans `partial` (jamais un faux zéro muet) et n'est pas gardé en cache 15 s ; sujets des incidents de remise", async () => {349 const before = await admin.call("GET", "/api/next/dashboard?fresh=1")350 assert.deepEqual(before.partial, [])351 assert.equal(before.attention.flagged, 1)352 // incident de remise : ligne de la file rattachée à un message réel (sujet lu), une autre dont le message a disparu (sujet null)353 const acct = (await admin.call("GET", `/api/jmap/${P.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]354 const r = await admin.jmap(P.id, [["Email/query", { accountId: acct, filter: { subject: "Devis toiture alpha" }, limit: 1 }, "q"]])355 const emailId = r[0][1].ids[0] as string356 assert.ok(emailId)357 const [me] = await sql`select id from users where handle = 'owner'`358 const issue = (id: string, eid: string | null) => sql`insert into outbound_messages (id, user_id, from_address, mailbox_id, email_id, recipients, status, external, updated_at)359 values (${id}, ${me.id}, ${P.address}, ${P.id}, ${eid}, ${sql.json([{ address: X.address, status: "bounced", smtp_reply: "550 5.1.1 no such user" }])}, 'bounced', false, now())`360 await issue(`out_dash1${RUN}`, emailId)361 await issue(`out_dash2${RUN}`, "disparu")362 const withIssues = await admin.call("GET", "/api/next/dashboard?fresh=1")363 const subjects = new Map(withIssues.delivery_issues.map((o: any) => [o.id, o.subject]))364 assert.equal(subjects.get(`out_dash1${RUN}`), "Devis toiture alpha")365 assert.equal(subjects.get(`out_dash2${RUN}`), null, "message introuvable : sujet null, la ligne reste")366 assert.deepEqual(withIssues.partial, [])367 // panne d'une boîte : son compte de courrier ne répond plus aux requêtes JMAP368 const [orig] = await sql`select stalwart_id from mailboxes where id = ${Q.id}`369 await sql`update mailboxes set stalwart_id = 'zzzzzzzz' where id = ${Q.id}`370 try {371 const broken = await admin.call("GET", "/api/next/dashboard?fresh=1")372 for (const name of ["attention", "attention.flagged", "attention.unanswered", "inbox", "pending_replies", "recent_attachments", "sync"]) assert.ok(broken.partial.includes(name), `${name} dans ${JSON.stringify(broken.partial)}`)373 assert.ok(!broken.partial.includes("scheduled") && !broken.partial.includes("top_contacts") && !broken.partial.includes("attention.reminders_due"), "les blocs lus en base restent mesurés")374 assert.deepEqual(broken.inbox.map((i: any) => i.mailbox_id), [P.id], "la boîte qui répond garde ses compteurs")375 assert.equal(broken.sync.mail_server, "reachable")376 // rétablie : la lecture suivante SANS `fresh` n'est pas la réponse partielle (cache de 2 s, pas 15 s)377 await sql`update mailboxes set stalwart_id = ${orig.stalwart_id} where id = ${Q.id}`378 await sleep(2300)379 const healed = await admin.call("GET", "/api/next/dashboard")380 assert.notEqual(healed.generated_at, broken.generated_at, "résultat partiel non servi par le cache")381 assert.deepEqual(healed.partial, [])382 assert.equal(healed.attention.flagged, 1)383 } finally {384 await sql`update mailboxes set stalwart_id = ${orig.stalwart_id} where id = ${Q.id}`385 await sql`delete from outbound_messages where id in (${`out_dash1${RUN}`}, ${`out_dash2${RUN}`})`386 }387})388389test("tableau de bord : lectures simultanées sans bloc perdu (la limite de requêtes simultanées du serveur de courrier est rejouée, pas avalée)", async () => {390 // Un tableau lance une dizaine de lectures JMAP par boîte ; trois tableaux à la fois dépassent la limite par compte de Stalwart391 // (400 « maxConcurrentRequests »). Chaque bloc doit pourtant être mesuré : aucun `partial`, mêmes compteurs.392 for (let round = 0; round < 3; round++) {393 const all = await Promise.all([1, 2, 3].map(() => admin.call("GET", "/api/next/dashboard?fresh=1")))394 for (const d of all) {395 assert.deepEqual(d.partial, [], `tour ${round}`)396 assert.equal(d.attention.flagged, 1)397 assert.equal(d.inbox.length, 2)398 assert.equal(d.recent_attachments.length, 3)399 }400 }401})402403test("tableau de bord : « réponses attendues » borné à 10 même avec davantage de fils en attente", async () => {404 // 14 fils non lus déposés par JMAP dans la réception de Q (aucun envoi réel)405 const acct = (await admin.call("GET", `/api/jmap/${Q.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]406 const boxes = (await admin.jmap(Q.id, [["Mailbox/get", { accountId: acct, ids: null, properties: ["role"] }, "m"]]))[0][1].list as any[]407 const inbox = boxes.find((b) => b.role === "inbox").id408 const create: Record<string, unknown> = {}409 for (let i = 0; i < 14; i++) create[`p${i}`] = { mailboxIds: { [inbox]: true }, from: [{ email: X.address }], to: [{ email: Q.address }], subject: `Attente bornée ${i} ${RUN}`, receivedAt: new Date(Date.now() - i * 60_000).toISOString(), bodyValues: { b: { value: "x" } }, textBody: [{ partId: "b", type: "text/plain" }] }410 const set = (await admin.jmap(Q.id, [["Email/set", { accountId: acct, create }, "s"]]))[0][1]411 assert.equal(Object.keys(set.created ?? {}).length, 14, JSON.stringify(set.notCreated ?? {}))412 const d = await admin.call("GET", "/api/next/dashboard?fresh=1")413 assert.equal(d.pending_replies.length, 10)414 assert.ok(d.attention.unanswered >= 14, "le compteur dit le total examiné, la liste est bornée")415 await admin.jmap(Q.id, [["Email/set", { accountId: acct, destroy: Object.values<any>(set.created).map((c) => c.id) }, "d"]])416})417