Repository Public
1// SP Mail Next — envoi : annulation d'envoi (vraie retenue côté serveur, contenu rendu pour rouvrir la rédaction), destinataires sensibles2// à confirmer, rappel à l'envoi. Vrai courrier entre boîtes de recette : rien n'arrive pendant la fenêtre, rien n'arrive après une annulation.3import assert from "node:assert/strict"4import crypto from "node:crypto"5import { after, before, test } from "node:test"6import { ApiError, ApiKey, Client, V1Error, cli, expectV1, sleep, sql, startServer, stopServer, tokenOf, until } from "../harness"7import { mkKey, mkMailbox, purgeAll, sess, setupAdmin, type Box } from "./v1-helpers"89let admin: Client, member: Client10let S: Box, R: Box, T: Box11let ks: ApiKey, kr: ApiKey, kt: ApiKey12const ALL = ["mail.send", "mail.read", "mail.search", "mail.modify", "mail.drafts", "mail.attachments.read", "mail.attachments.write"]13const PDF = crypto.randomBytes(12_000)1415const inbox = async (k: ApiKey, subject: string) => (await k.call("GET", "/messages?folder=inbox&limit=100")).data.find((m: any) => m.subject === subject)16const arrives = (k: ApiKey, subject: string) => until(() => inbox(k, subject), `réception de « ${subject} »`)17const send = async (c: Client, body: Record<string, unknown>) => { const r = await c.raw("POST", "/api/v1/messages/send", body); return { status: r.status, body: await r.json() } }18const outbound = async (id: string) => (await sql`select * from outbound_messages where id = ${id}`)[0]19const waitStatus = (id: string, ...statuses: string[]) => until(async () => { const o = await outbound(id); return statuses.includes(o.status) ? o : null }, `état ${statuses.join("/")}`)20async function rejects(p: Promise<unknown>, status: number, code?: string) {21 await assert.rejects(p, (e: unknown) => e instanceof ApiError && e.status === status && (!code || e.code === code), `attendu ${status} ${code ?? ""}`)22}2324before(async () => {25 await startServer()26 admin = await setupAdmin()27 member = new Client("web")28 await member.enroll(tokenOf(await cli("invite")), "membre", "Membre")29 const memberId = (await sql`select id from users where handle = 'membre'`)[0].id30 ;[S, R, T] = await Promise.all([mkMailbox(admin, "us"), mkMailbox(admin, "ur", memberId), mkMailbox(admin, "ut", memberId)])31 ks = await mkKey(admin, { scopes: ALL, addresses: [S.addressId] })32 kr = await mkKey(admin, { scopes: ALL, addresses: [R.addressId] })33 kt = await mkKey(admin, { scopes: ALL, addresses: [T.addressId] })34})35after(async () => {36 await purgeAll(admin)37 await stopServer()38})3940test("annulation d'envoi : message retenu, contenu rendu pour rouvrir la rédaction, annulé → jamais remis", async () => {41 const up = await admin.raw("POST", `/api/v1/files?filename=${encodeURIComponent("devis été.pdf")}&address=${encodeURIComponent(S.address)}`, new Uint8Array(PDF), { "content-type": "application/pdf" })42 assert.equal(up.status, 201)43 const file = await up.json()44 const t0 = Date.now()45 const r = await send(admin, {46 from: S.address, to: [{ email: R.address, name: "Destinataire R" }], cc: [T.address], subject: "Retenu puis annulé", text: "Version texte.",47 html: '<p>Bonjour <b>R</b><script>alert(1)</script></p>', attachments: [{ file_id: file.id }], undo_seconds: 6,48 })49 assert.equal(r.status, 202)50 assert.equal(r.body.status, "scheduled")51 assert.deepEqual(r.body.recipients.map((x: any) => [x.address, x.status]).sort(), [[R.address, "scheduled"], [T.address, "scheduled"]].sort())52 const until6 = Date.parse(r.body.undo_until)53 assert.ok(until6 - t0 >= 5000 && until6 - t0 <= 9000, `undo_until = maintenant + 6 s (écart ${until6 - t0} ms)`)54 assert.equal(r.body.send_at, r.body.undo_until)55 const id = r.body.id as string56 // pendant la fenêtre : rien chez le destinataire, rien dans la file du serveur de courrier57 await sleep(1500)58 assert.equal(await inbox(kr, "Retenu puis annulé"), undefined)59 const row = await outbound(id)60 assert.deepEqual([row.status, row.submission_id, row.submitted_at], ["scheduled", null, null])61 // le contenu retenu revient tel qu'il partirait (HTML assaini), pièces jointes comprises62 const held = await admin.call("GET", `/api/next/compose/undo/${id}`)63 assert.deepEqual([held.id, held.status, held.mailbox_id, held.subject, held.text, held.html], [id, "scheduled", S.id, "Retenu puis annulé", "Version texte.", "<p>Bonjour <b>R</b></p>"])64 assert.deepEqual([held.from.email, held.to, held.cc, held.bcc], [S.address, [{ email: R.address, name: "Destinataire R" }], [{ email: T.address, name: null }], []])65 assert.deepEqual(held.attachments.map((a: any) => [a.name, a.type, a.size, a.inline]), [["devis été.pdf", "application/pdf", PDF.length, false]])66 assert.ok(held.attachments[0].blob_id && held.email_id && held.thread_id)67 assert.deepEqual([held.in_reply_to, held.references, held.undo_until, held.send_at], [[], [], r.body.undo_until, r.body.undo_until])68 // la pièce jointe est encore lisible par la passerelle JMAP (le client peut la rattacher à son nouveau brouillon)69 const acct = (await admin.call("GET", `/api/jmap/${S.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]70 const blob = await admin.raw("GET", `/api/jmap/${S.id}/download/${acct}/${held.attachments[0].blob_id}/devis.pdf?accept=application/pdf`)71 assert.ok(Buffer.from(await blob.arrayBuffer()).equals(PDF))72 // réservé à la session qui l'a créé73 await rejects(member.call("GET", `/api/next/compose/undo/${id}`), 404, "not_found")74 await rejects(admin.call("GET", "/api/next/compose/undo/msg_out_aaaaaaaaaaaaaaaaaaaa"), 404, "not_found")75 await rejects(admin.call("GET", "/api/next/compose/undo/n-importe-quoi"), 404, "not_found")76 assert.equal((await new Client("web").raw("GET", `/api/next/compose/undo/${id}`)).status, 401)77 await rejects(member.call("POST", `/api/next/compose/undo/${id}`), 404, "not_found")78 // annulation qui garde le brouillon : la rédaction reprend dessus, pièce jointe comprise79 const undone = await admin.call("POST", `/api/next/compose/undo/${id}`)80 assert.deepEqual({ ...undone, status: "scheduled", draft: undefined }, { ...held, draft: undefined })81 assert.deepEqual([undone.status, undone.draft], ["cancelled", true])82 await rejects(admin.call("GET", `/api/next/compose/undo/${id}`), 409, "not_cancellable")83 await rejects(admin.call("POST", `/api/next/compose/undo/${id}`), 409, "not_cancellable")84 await expectV1(sess(admin, "DELETE", `/messages/scheduled/${id}`), 409, "not_cancellable")85 const again = await admin.raw("GET", `/api/jmap/${S.id}/download/${acct}/${held.attachments[0].blob_id}/devis.pdf?accept=application/pdf`)86 assert.equal(again.status, 200)87 assert.ok(Buffer.from(await again.arrayBuffer()).equals(PDF))88 // après la fenêtre : rien n'est parti, nulle part ; le message est redevenu un simple brouillon89 await sleep(Math.max(0, until6 - Date.now()) + 3500)90 assert.equal(await inbox(kr, "Retenu puis annulé"), undefined)91 assert.equal(await inbox(kt, "Retenu puis annulé"), undefined)92 const final = await outbound(id)93 assert.deepEqual([final.status, final.submission_id, final.submitted_at], ["cancelled", null, null])94 const draft = (await sess(admin, "GET", "/drafts")).data.find((m: any) => m.subject === "Retenu puis annulé")95 assert.ok(draft && draft.draft && draft.has_attachment, "le brouillon est dans « Brouillons »")96 assert.deepEqual(draft.folders.map((f: any) => f.role), ["drafts"])97 // et ce brouillon se renvoie normalement : il arrive avec sa pièce jointe intacte98 const resent = await sess(admin, "POST", `/drafts/${draft.id}/send`, {})99 assert.equal(resent.status, "sent")100 const got = await arrives(kr, "Retenu puis annulé")101 const full = await kr.call("GET", `/messages/${got.id}`)102 assert.ok(Buffer.from(await (await kr.raw("GET", `/messages/${got.id}/attachments/${full.attachments[0].id}`)).arrayBuffer()).equals(PDF))103})104105test("annulation d'envoi par la route existante (DELETE) : le brouillon est détruit, rien n'est remis", async () => {106 const r = await send(admin, { from: S.address, to: [R.address], subject: "Annulé et détruit", text: "x", undo_seconds: 4 })107 assert.equal(r.status, 202)108 const cancel = await sess(admin, "DELETE", `/messages/scheduled/${r.body.id}`)109 assert.equal(cancel.status, "cancelled")110 await rejects(admin.call("GET", `/api/next/compose/undo/${r.body.id}`), 409, "not_cancellable")111 await sleep(Math.max(0, Date.parse(r.body.undo_until) - Date.now()) + 3000)112 assert.equal(await inbox(kr, "Annulé et détruit"), undefined)113 assert.deepEqual([(await outbound(r.body.id)).status, (await outbound(r.body.id)).submission_id], ["cancelled", null])114 assert.ok(!(await ks.call("GET", "/messages?limit=100")).data.some((m: any) => m.subject === "Annulé et détruit"), "aucune copie dans la boîte de l'expéditeur")115})116117test("annulation d'envoi : sans annulation, le message part à la fin de la fenêtre et est remis", async () => {118 const r = await send(admin, { from: S.address, to: [R.address], subject: "Retenu puis remis", text: "Trois secondes de réflexion.", undo_seconds: 3 })119 assert.equal(r.status, 202)120 const id = r.body.id as string121 const at = Date.parse(r.body.undo_until)122 assert.ok((await sess(admin, "GET", "/messages/scheduled")).data.some((x: any) => x.id === id && x.undo_until === r.body.undo_until))123 await sleep(1000)124 assert.equal(await inbox(kr, "Retenu puis remis"), undefined, "rien n'est parti pendant la fenêtre")125 assert.equal((await outbound(id)).status, "scheduled")126 const done = await waitStatus(id, "delivered")127 assert.ok(new Date(done.submitted_at).getTime() >= at - 50, "soumis seulement après la fenêtre")128 const got = await arrives(kr, "Retenu puis remis")129 assert.equal((await kr.call("GET", `/messages/${got.id}`)).text.trim(), "Trois secondes de réflexion.")130 // une fois parti : plus rien à annuler ni à rouvrir131 await rejects(admin.call("GET", `/api/next/compose/undo/${id}`), 409, "not_cancellable")132 await expectV1(sess(admin, "DELETE", `/messages/scheduled/${id}`), 409, "not_cancellable")133 assert.equal((await sess(admin, "GET", `/messages/outbound/${id}`)).status, "delivered")134})135136test("undo_seconds : bornes, cas sans effet, réponse, clé d'API ; l'expéditeur reste soumis à l'autorisation existante", async () => {137 for (const bad of [121, -1, 2.5, "10"]) assert.equal((await send(admin, { from: S.address, to: [R.address], subject: "x", text: "x", undo_seconds: bad })).status, 400, String(bad))138 // 0 = envoi immédiat, comme sans le champ139 const now = await send(admin, { from: S.address, to: [R.address], subject: "Sans retenue", text: "x", undo_seconds: 0 })140 assert.deepEqual([now.status, now.body.status, now.body.undo_until], [200, "sent", undefined])141 await arrives(kr, "Sans retenue")142 // avec une programmation explicite, c'est send_at qui compte (déjà annulable) ; un brouillon reste un brouillon143 const at = new Date(Date.now() + 3600_000).toISOString()144 const later = await send(admin, { from: S.address, to: [R.address], subject: "Programmé", text: "x", send_at: at, undo_seconds: 5 })145 assert.deepEqual([later.status, later.body.status, later.body.undo_until, Date.parse(later.body.send_at)], [202, "scheduled", undefined, Date.parse(at)])146 assert.equal((await admin.call("GET", `/api/next/compose/undo/${later.body.id}`)).subject, "Programmé", "un message programmé se rouvre aussi")147 await sess(admin, "DELETE", `/messages/scheduled/${later.body.id}`)148 const draft = await send(admin, { from: S.address, to: [R.address], subject: "Brouillon", text: "x", draft: true, undo_seconds: 5 })149 assert.deepEqual([draft.status, draft.body.status], [201, "draft"])150 // usurpation : une adresse d'autrui est refusée, avec ou sans retenue151 const spoof = await send(admin, { from: R.address, to: [T.address], subject: "Usurpation", text: "x", undo_seconds: 5 })152 assert.deepEqual([spoof.status, spoof.body.error.code], [403, "from_not_allowed"])153 assert.equal((await sql`select count(*)::int as n from outbound_messages where from_address = ${R.address}`)[0].n, 0)154 // réponse retenue : même mécanisme155 await kr.call("POST", "/messages/send", { from: R.address, to: [S.address], subject: "Message de R", text: "x" })156 const original = await arrives(ks, "Message de R")157 const rep = await admin.raw("POST", `/api/v1/messages/${original.id}/reply`, { text: "Réponse retenue.", undo_seconds: 2 })158 assert.equal(rep.status, 202)159 const repBody = await rep.json()160 assert.ok(repBody.undo_until && repBody.status === "scheduled")161 assert.equal(await inbox(kr, "Re: Message de R"), undefined)162 await arrives(kr, "Re: Message de R")163 // clé d'API : la retenue fonctionne aussi, mais le contenu retenu n'est rendu qu'à une session d'appareil, pour ses propres envois164 const byKey = await ks.res("POST", "/messages/send", { from: S.address, to: [R.address], subject: "Retenu par clé", text: "x", undo_seconds: 2 })165 assert.deepEqual([byKey.status, byKey.body.status, typeof byKey.body.undo_until], [202, "scheduled", "string"])166 await rejects(admin.call("GET", `/api/next/compose/undo/${byKey.body.id}`), 404, "not_found")167 await arrives(kr, "Retenu par clé")168})169170test("destinataires sensibles : 409 confirmation_required sans rien mettre en file, puis envoi confirmé ; clés d'API non concernées", async () => {171 await admin.call("PUT", "/api/next/compose/prefs", { sensitive: [T.address.toUpperCase()] })172 const before = (await sql`select count(*)::int as n from outbound_messages`)[0].n173 const e = await sess(admin, "POST", "/messages/send", { from: S.address, to: [R.address], cc: [T.address], subject: "Sensible", text: "x" }).then(() => null, (x) => x as V1Error)174 assert.ok(e instanceof V1Error)175 assert.deepEqual([e.status, e.code, e.body.error.details], [409, "confirmation_required", { recipients: [T.address] }])176 assert.equal((await send(admin, { from: S.address, to: [T.address], subject: "Sensible", text: "x", confirm_sensitive: false, undo_seconds: 5 })).status, 409)177 assert.equal((await sql`select count(*)::int as n from outbound_messages`)[0].n, before, "rien n'a été mis en file")178 assert.ok(!(await ks.call("GET", "/messages?folder=drafts&limit=100")).data.some((m: any) => m.subject === "Sensible"), "aucun brouillon laissé derrière")179 // un destinataire ordinaire n'est pas concerné ; un brouillon non plus180 assert.equal((await send(admin, { from: S.address, to: [R.address], subject: "Ordinaire", text: "x" })).status, 200)181 assert.equal((await send(admin, { from: S.address, to: [T.address], subject: "Brouillon sensible", text: "x", draft: true })).status, 201)182 // confirmé : le message part et arrive183 const ok = await send(admin, { from: S.address, to: [T.address], subject: "Sensible confirmé", text: "x", confirm_sensitive: true })184 assert.deepEqual([ok.status, ok.body.status], [200, "sent"])185 await arrives(kt, "Sensible confirmé")186 // lot : chaque élément est jugé séparément187 const batch = await sess(admin, "POST", "/messages/send-batch", { messages: [{ from: S.address, to: [T.address], subject: "Lot 1", text: "x" }, { from: S.address, to: [R.address], subject: "Lot 2", text: "x" }] })188 assert.deepEqual(batch.results.map((x: any) => [x.ok, x.status, x.error?.code ?? null]), [[false, 409, "confirmation_required"], [true, 200, null]])189 // forme « @domaine »190 await admin.call("PUT", "/api/next/compose/prefs", { sensitive: ["@stg.spboucher.ai"] })191 const dom = await send(admin, { from: S.address, to: [R.address], subject: "Domaine sensible", text: "x" })192 assert.deepEqual([dom.status, dom.body.error.details.recipients], [409, [R.address]])193 // une clé d'API n'est pas concernée ; un autre utilisateur a ses propres préférences194 assert.equal((await ks.res("POST", "/messages/send", { from: S.address, to: [T.address], subject: "Par clé", text: "x" })).status, 200)195 assert.equal((await send(member, { from: R.address, to: [S.address], subject: "Du membre", text: "x" })).status, 200)196 await admin.call("PUT", "/api/next/compose/prefs", {})197 assert.equal((await send(admin, { from: S.address, to: [T.address], subject: "Plus sensible", text: "x" })).status, 200)198})199200test("rappel à l'envoi : remind_at porté par l'envoi, rappel créé une fois le message soumis ; réservé aux sessions", async () => {201 const due = new Date(Date.now() + 3600_000)202 const viaKey = await ks.res("POST", "/messages/send", { from: S.address, to: [R.address], subject: "x", text: "x", remind_at: due.toISOString() })203 assert.deepEqual([viaKey.status, viaKey.body.error.code], [403, "session_required"])204 assert.equal((await send(admin, { from: S.address, to: [R.address], subject: "x", text: "x", remind_at: "demain" })).status, 400)205 assert.equal((await send(admin, { from: S.address, to: [R.address], subject: "x", text: "x", remind_at: new Date(Date.now() + 400 * 86400_000).toISOString() })).status, 400)206 const hasReminders = !!(await sql`select to_regclass('public.reminders') as t`)[0].t207 const count = async () => (hasReminders ? (await sql`select count(*)::int as n from reminders`)[0].n as number : 0)208 const n0 = await count()209 // retenu 3 s : le rappel n'existe pas tant que le message n'est pas parti210 const r = await send(admin, { from: S.address, to: [R.address], subject: "À relancer", text: "Merci de répondre.", remind_at: due.toISOString(), remind_if_no_reply: true, undo_seconds: 3 })211 assert.equal(r.status, 202)212 const held = await outbound(r.body.id)213 assert.deepEqual([new Date(held.remind_at).getTime(), held.remind_if_no_reply, held.reminded_at], [due.getTime(), true, null])214 assert.equal(await count(), n0, "aucun rappel pendant la fenêtre d'annulation")215 await waitStatus(r.body.id, "sent", "delivered")216 const sent = await until(async () => { const o = await outbound(r.body.id); return !hasReminders || o.reminded_at ? o : null }, "rappel créé après la soumission")217 if (hasReminders) {218 const rows = await sql`select * from reminders where mailbox_id = ${S.id} and email_id = ${sent.email_id}`219 assert.equal(rows.length, 1)220 assert.deepEqual([rows[0].only_if_no_reply, new Date(rows[0].due_at).getTime(), rows[0].status, rows[0].subject], [true, due.getTime(), "pending", "À relancer"])221 assert.equal(await count(), n0 + 1)222 // le suivi de remise repasse sur le message : toujours un seul rappel223 await waitStatus(r.body.id, "delivered")224 await sleep(1500)225 assert.equal(await count(), n0 + 1)226 }227 // annulé pendant la fenêtre : jamais de rappel228 const c = await send(admin, { from: S.address, to: [R.address], subject: "Annulé avec rappel", text: "x", remind_at: due.toISOString(), undo_seconds: 4 })229 await sess(admin, "DELETE", `/messages/scheduled/${c.body.id}`)230 await sleep(5500)231 assert.equal((await outbound(c.body.id)).reminded_at, null)232 assert.equal(await count(), n0 + (hasReminders ? 1 : 0))233})234