Repository Public
1/**2 * =============================================================================3 * SP BOUCHER | SOFTWARE & RESEARCH4 * ARTIFICIAL INTELLIGENCE • FINANCE • ENGINEERING5 * =============================================================================6 *7 * Project : SP Mail8 * File : tests/integration/v1-addresses.test.ts9 * Module : tests10 * Repository : https://git.spboucher.ai/sp-mail11 * Project Website : https://mail.spboucher.ai12 * Created : 2026-11-1913 * Last Modified : 2026-11-1914 *15 * Author : Simon-Pierre Boucher16 * Position : Professor of Finance17 * Institution : Université du Québec en Outaouais (UQO)18 * Organization : SP Boucher19 * Website : https://spboucher.ai20 * Git : https://git.spboucher.ai21 *22 * Preferred Contact: support@spboucher.ai23 * Development : dev@spboucher.ai24 * Support : support@spboucher.ai25 * Security/Admin : admin@spboucher.ai26 *27 * Copyright (c) 202628 * Simon-Pierre Boucher29 * All rights reserved where applicable. This file is governed by the30 * applicable project license, copyright notices and relevant law.31 * Existing third-party rights and notices remain unaffected.32 *33 * License : None specified (no license file in this repository)34 *35 * Do not embed credentials, private keys, access tokens,36 * certificates or confidential personal information.37 *38 * =============================================================================39 * END OF SP BOUCHER SOURCE HEADER40 * =============================================================================41 */4243// /api/v1 — adresses de première classe : cycle de vie réel sur le serveur de courrier (remise, suspension, expiration, protection…).44import assert from "node:assert/strict"45import { after, before, test } from "node:test"46import { ApiKey, Client, cli, expectV1, reauth, sleep, sql, startServerWith, stopServer, tokenOf, until } from "../harness"47import { addr, aliasOf, mkKey, mkMailbox, purgeAll, sendAndWait, sess, setupAdmin, stalwartAccount, type Box } from "./v1-helpers"4849let admin: Client50let A: Box, B: Box, C: Box51let sendB: ApiKey, sendC: ApiKey, readA: ApiKey, readB: ApiKey, readC: ApiKey52const POSTMASTER = addr("postmaster")5354async function rejects(p: Promise<unknown>, status: number, code?: string) {55 await assert.rejects(p, (e: any) => e.status === status && (!code || e.code === code))56}57const inbox = async (k: ApiKey, subject: string) => (await k.call("GET", "/messages?folder=inbox&limit=50")).data.find((m: any) => m.subject === subject)58const arrives = (k: ApiKey, subject: string) => until(() => inbox(k, subject), `réception de « ${subject} »`)5960before(async () => {61 await startServerWith({ SPMAIL_PROTECTED_ADDRESSES: POSTMASTER })62 admin = await setupAdmin()63 ;[A, B, C] = await Promise.all([mkMailbox(admin, "main"), mkMailbox(admin, "other"), mkMailbox(admin, "third")])64 sendB = await mkKey(admin, { scopes: ["mail.send", "mail.read"], addresses: [B.addressId] })65 sendC = await mkKey(admin, { scopes: ["mail.send", "mail.read"], addresses: [C.addressId] })66 readA = await mkKey(admin, { scopes: ["mail.read", "mail.search"], addresses: [A.addressId] })67 readB = sendB68 readC = sendC69})70after(async () => {71 await purgeAll(admin)72 await stopServer()73})7475test("reprise : une adresse par boîte, une par alias du serveur ; idempotente ; les routes historiques tiennent la table à jour", async () => {76 const rows = await sql`select address, kind, status, protected from addresses order by address`77 assert.deepEqual(rows.map((r) => [r.address, r.kind]), [A.address, B.address, C.address].sort().map((a) => [a, "mailbox"]))78 // alias posé par l'ancienne route d'administration → adresse « alias » ; l'adresse nommée dans SPMAIL_PROTECTED_ADDRESSES est protégée79 await admin.call("PUT", `/api/admin/mailboxes/${A.id}/aliases`, { aliases: [POSTMASTER, addr("legacy")] })80 const al = await sql`select address, kind, protected, mailbox_id from addresses where kind = 'alias' order by address`81 assert.deepEqual(al.map((r) => [r.address, r.protected]), [[addr("legacy"), false], [POSTMASTER, true]])82 assert.match(await cli("addresses-sync"), /0 adresse\(s\) ajoutée\(s\)/)83 assert.equal((await admin.call("POST", "/api/admin/addresses/sync", {})).created.length, 0)84 // retrait par l'ancienne route : la ligne disparaît ; un alias protégé ne peut pas être retiré85 await rejects(admin.call("PUT", `/api/admin/mailboxes/${A.id}/aliases`, { aliases: [addr("legacy")] }), 403, "protected_address")86 await admin.call("PUT", `/api/admin/mailboxes/${A.id}/aliases`, { aliases: [POSTMASTER] })87 assert.equal((await sql`select 1 from addresses where address = ${addr("legacy")}`).length, 0)88 assert.ok(aliasOf(await stalwartAccount(A.address), POSTMASTER))89})9091test("adresses protégées : ni suppression, ni suspension, ni changement de nature, par aucune API", async () => {92 const p = (await sess(admin, "GET", `/addresses/${POSTMASTER}`))93 assert.equal(p.protected, true)94 await reauth(admin)95 await expectV1(sess(admin, "DELETE", `/addresses/${p.id}`, {}), 403, "protected_address")96 await expectV1(sess(admin, "DELETE", `/aliases/${p.id}`), 403, "protected_address")97 for (const patch of [{ status: "suspended" }, { kind: "temporary", expires_at: new Date(Date.now() + 1e6).toISOString() }, { can_receive: false }, { expires_at: new Date(Date.now() + 1e6).toISOString() }, { protected: false }, { extra_destinations: [B.address] }, { reply_policy: "discard" }])98 await expectV1(sess(admin, "PATCH", `/addresses/${p.id}`, patch), 403, "protected_address")99 // la boîte qui porte une adresse protégée ne peut être ni détachée ni purgée100 await expectV1(sess(admin, "DELETE", `/addresses/${A.addressId}?purge=delete-all-mail`, { confirm: "delete-all-mail" }), 403, "protected_address")101 await rejects(admin.call("DELETE", `/api/admin/mailboxes/${A.id}?purge=delete-all-mail`), 403, "protected_address")102 await rejects(admin.call("DELETE", `/api/admin/mailboxes/${A.id}`), 403, "protected_address")103 const adminKey = await mkKey(admin, { scopes: ["mail.admin"], all: true })104 await expectV1(adminKey.call("DELETE", `/addresses/${p.id}`, {}), 403, "protected_address")105 await expectV1(adminKey.call("PATCH", `/addresses/${p.id}`, { status: "suspended" }), 403, "protected_address")106 // les réglages non destructifs restent possibles ; la protection se pose mais ne s'enlève pas107 assert.equal((await sess(admin, "PATCH", `/addresses/${p.id}`, { display_name: "Postmaster" })).display_name, "Postmaster")108 assert.equal((await sess(admin, "GET", `/addresses/${p.id}`)).status, "active")109 assert.ok(aliasOf(await stalwartAccount(A.address), POSTMASTER).enable !== false)110 const [still] = await sql`select 1 from mailboxes where id = ${A.id}`111 assert.ok(still)112})113114test("alias : création → remise RÉELLE dans la boîte cible → suspension → remise refusée (550) → réactivation", async () => {115 const AL = addr("sales")116 const al = await sess(admin, "POST", "/aliases", { address: AL, mailbox: A.address, display_name: "Ventes" })117 assert.equal(al.kind, "alias")118 assert.equal(al.mailbox, A.address)119 assert.equal(al.inbound, "accept")120 await expectV1(sess(admin, "POST", "/aliases", { address: AL, mailbox: B.address }), 409, "address_taken")121 await expectV1(sess(admin, "POST", "/aliases", { address: A.address, mailbox: B.address }), 409, "address_taken")122 await expectV1(sess(admin, "POST", "/aliases", { address: `x@not-hosted.example`, mailbox: A.address }), 400, "unknown_domain")123 await expectV1(sess(admin, "POST", "/aliases", { address: addr("nobox") }), 400, "mailbox_required")124 await expectV1(sess(admin, "POST", "/aliases", { address: addr("nobox"), mailbox: AL }), 400, "unknown_mailbox")125126 const d1 = await sendAndWait(sendB, { from: B.address, to: [AL], subject: "alias 1", text: "bonjour" })127 assert.equal(d1.status, "delivered")128 assert.match(d1.recipients[0].smtp_reply, /^250 /)129 const m = await arrives(readA, "alias 1")130 assert.deepEqual(m.delivered_to, [AL])131 assert.equal(m.mailbox, A.address)132133 // suspension : l'alias est désactivé SUR LE SERVEUR DE COURRIER, la remise est refusée en SMTP134 const k = await mkKey(admin, { scopes: ["mail.send", "mail.read"], addresses: [al.id] })135 const sus = await sess(admin, "PATCH", `/aliases/${al.id}`, { status: "suspended" })136 assert.equal(sus.status, "suspended")137 assert.equal(sus.inbound, "reject")138 assert.equal(aliasOf(await stalwartAccount(A.address), AL).enable, false)139 const d2 = await sendAndWait(sendB, { from: B.address, to: [AL], subject: "alias 2 (suspendu)", text: "refusé" })140 assert.equal(d2.status, "bounced")141 assert.match(d2.recipients[0].smtp_reply, /^550 5\.1\.1/)142 assert.equal(await inbox(readA, "alias 2 (suspendu)"), undefined)143 // une adresse suspendue ne peut ni envoyer ni être lue par une clé144 await expectV1(k.call("POST", "/messages/send", { from: AL, to: [B.address], subject: "x", text: "x" }), 403, "address_inactive")145 await expectV1(k.call("GET", `/messages?address=${AL}`), 403, "address_inactive")146 assert.deepEqual((await k.call("GET", "/messages")).data, [])147 const ev = (await sess(admin, "GET", "/events?type=address.suspended")).data148 assert.ok(ev.some((e: any) => e.address === AL))149150 // réactivation151 const re = await sess(admin, "PATCH", `/aliases/${al.id}`, { status: "active" })152 assert.equal(re.inbound, "accept")153 assert.notEqual(aliasOf(await stalwartAccount(A.address), AL).enable, false)154 const d3 = await sendAndWait(sendB, { from: B.address, to: [AL], subject: "alias 3 (réactivé)", text: "revenu" })155 assert.equal(d3.status, "delivered")156 await arrives(readA, "alias 3 (réactivé)")157158 // envoi au nom de l'alias : identité créée automatiquement, le From reçu est celui de l'alias avec son nom159 await sess(admin, "PATCH", `/aliases/${al.id}`, { signature_text: "-- \nVentes", signature_html: "<p>Ventes</p>" })160 const out = await sendAndWait(k, { from: AL, to: [B.address], subject: "depuis l'alias", text: "identité d'alias" })161 assert.equal(out.status, "delivered")162 assert.equal(out.from, AL)163 const got = await arrives(readB, "depuis l'alias")164 assert.deepEqual(got.from, [{ email: AL, name: "Ventes" }])165 const idents = (await admin.jmap(A.id, [["Identity/get", { accountId: (await admin.call("GET", `/api/jmap/${A.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"] }, "i"]]))[0][1].list166 const ident = idents.find((i: any) => i.email === AL)167 assert.equal(ident.name, "Ventes")168 assert.equal(ident.htmlSignature, "<p>Ventes</p>")169 // la clé limitée à l'alias voit son envoi et ce qui lui a été remis, pas le reste de la boîte170 const mine = (await k.call("GET", "/messages")).data.map((x: any) => x.subject).sort()171 assert.deepEqual(mine, ["alias 1", "alias 3 (réactivé)", "depuis l'alias"])172173 // suppression : l'alias disparaît du serveur, la remise est refusée174 await reauth(admin)175 assert.deepEqual(await sess(admin, "DELETE", `/aliases/${al.id}`), { ok: true, purged: false })176 assert.equal(aliasOf(await stalwartAccount(A.address), AL), undefined)177 await expectV1(sess(admin, "GET", `/addresses/${al.id}`), 404)178})179180test("send-only (reject / discard / accept), receive-only, temporaire avec expiration appliquée par le travailleur", async () => {181 const NR = addr("noreply"), RO = addr("intake"), TMP = addr("tmp")182 const nr = await sess(admin, "POST", "/addresses", { address: NR, kind: "send_only", mailbox: A.address, display_name: "Ne pas répondre" })183 assert.equal(nr.can_send, true)184 assert.equal(nr.can_receive, false)185 assert.equal(nr.reply_policy, "reject")186 assert.equal(nr.inbound, "reject")187 const k = await mkKey(admin, { scopes: ["mail.send"], addresses: [nr.id] })188 // envoie (identité de la boîte, From = adresse d'envoi seul)…189 const o = await sendAndWait(k, { from: NR, to: [B.address], subject: "notification", text: "ne pas répondre" })190 assert.equal(o.status, "delivered")191 assert.equal((await arrives(readB, "notification")).from[0].email, NR)192 // … mais ne reçoit pas : reject = 550193 const r1 = await sendAndWait(sendB, { from: B.address, to: [NR], subject: "réponse 1", text: "x" })194 assert.equal(r1.status, "bounced")195 assert.match(r1.recipients[0].smtp_reply, /^550/)196 // discard = accepté par le serveur puis jeté (rien dans la boîte)197 assert.equal((await sess(admin, "PATCH", `/addresses/${nr.id}`, { reply_policy: "discard" })).inbound, "discard")198 const r2 = await sendAndWait(sendB, { from: B.address, to: [NR], subject: "réponse 2", text: "x" })199 assert.equal(r2.status, "delivered")200 await sendAndWait(sendB, { from: B.address, to: [A.address], subject: "témoin après discard", text: "x" })201 await arrives(readA, "témoin après discard")202 assert.equal(await inbox(readA, "réponse 2"), undefined, "le message jeté n'est pas dans la boîte")203 // accept = les réponses sont gardées204 assert.equal((await sess(admin, "PATCH", `/addresses/${nr.id}`, { reply_policy: "accept" })).inbound, "accept")205 const r3 = await sendAndWait(sendB, { from: B.address, to: [NR], subject: "réponse 3", text: "x" })206 assert.equal(r3.status, "delivered")207 await arrives(readA, "réponse 3")208209 // receive-only : reçoit, n'envoie jamais210 const ro = await sess(admin, "POST", "/addresses", { address: RO, kind: "receive_only", mailbox: A.address })211 assert.equal(ro.can_send, false)212 const kro = await mkKey(admin, { scopes: ["mail.send", "mail.read"], addresses: [ro.id] })213 await expectV1(kro.call("POST", "/messages/send", { from: RO, to: [B.address], subject: "x", text: "x" }), 403, "address_cannot_send")214 assert.equal((await sendAndWait(sendC, { from: C.address, to: [RO], subject: "formulaire", text: "x" })).status, "delivered")215 await until(async () => (await kro.call("GET", "/messages")).data.some((m: any) => m.subject === "formulaire"), "réception receive-only")216217 // temporaire : expires_at obligatoire ; à l'échéance l'API refuse tout de suite, puis le travailleur désactive l'alias218 await expectV1(sess(admin, "POST", "/addresses", { address: TMP, kind: "temporary", mailbox: A.address }), 400, "expires_at_required")219 const tmp = await sess(admin, "POST", "/addresses", { address: TMP, kind: "temporary", mailbox: A.address, expires_at: new Date(Date.now() + 6000).toISOString() })220 const kt = await mkKey(admin, { scopes: ["mail.send"], addresses: [tmp.id] })221 assert.equal((await sendAndWait(sendC, { from: C.address, to: [TMP], subject: "avant expiration", text: "x" })).status, "delivered")222 await sleep(Math.max(0, new Date(tmp.expires_at).getTime() - Date.now() + 200))223 await expectV1(kt.call("POST", "/messages/send", { from: TMP, to: [B.address], subject: "x", text: "x" }), 403, "address_inactive")224 const exp = await until(async () => { const a = await sess(admin, "GET", `/addresses/${tmp.id}`); return a.status === "suspended" ? a : null }, "expiration appliquée par le travailleur", 15000)225 assert.equal(exp.suspended_reason, "expired")226 assert.equal(aliasOf(await stalwartAccount(A.address), TMP).enable, false)227 const late = await sendAndWait(sendC, { from: C.address, to: [TMP], subject: "après expiration", text: "x" })228 assert.equal(late.status, "bounced")229 assert.ok((await sess(admin, "GET", "/events?type=address.suspended")).data.some((e: any) => e.address === TMP && e.data.reason === "expired"))230})231232test("alias à plusieurs destinations (liste de diffusion du serveur), limité aux adresses locales", async () => {233 const TEAM = addr("team")234 await expectV1(sess(admin, "POST", "/aliases", { address: TEAM, mailbox: A.address, extra_destinations: ["someone@example.org"] }), 400, "invalid_destination")235 await expectV1(sess(admin, "POST", "/aliases", { address: TEAM, mailbox: A.address, extra_destinations: [A.address] }), 400, "invalid_destination")236 const team = await sess(admin, "POST", "/aliases", { address: TEAM, mailbox: A.address, extra_destinations: [B.address] })237 assert.deepEqual(team.extra_destinations, [B.address])238 assert.equal(aliasOf(await stalwartAccount(A.address), TEAM), undefined, "l'adresse est une liste, plus un alias de compte")239 const d = await sendAndWait(sendC, { from: C.address, to: [TEAM], subject: "à l'équipe", text: "x" })240 assert.equal(d.status, "delivered")241 await arrives(readA, "à l'équipe")242 await arrives(readB, "à l'équipe")243 // retour à une seule destination244 const single = await sess(admin, "PATCH", `/aliases/${team.id}`, { extra_destinations: [] })245 assert.deepEqual(single.extra_destinations, [])246 assert.ok(aliasOf(await stalwartAccount(A.address), TEAM))247 assert.equal((await sendAndWait(sendC, { from: C.address, to: [TEAM], subject: "à A seule", text: "x" })).status, "delivered")248 await arrives(readA, "à A seule")249 await sendAndWait(sendC, { from: C.address, to: [B.address], subject: "témoin B", text: "x" })250 await arrives(readB, "témoin B")251 assert.equal(await inbox(readB, "à A seule"), undefined)252})253254test("boîte physique : quota appliqué, suspension réelle (réception 550, soumission interdite), création et purge par /api/v1", async () => {255 // quota → propriété du compte sur le serveur de courrier256 const plain = await sess(admin, "POST", "/aliases", { address: addr("plain"), mailbox: C.address })257 await expectV1(sess(admin, "PATCH", `/addresses/${plain.id}`, { quota_bytes: 5_000_000 }), 400, "quota_mailbox_only")258 await expectV1(sess(admin, "PATCH", `/addresses/${plain.id}`, { retention_days: 30 }), 400, "retention_mailbox_only")259 assert.equal((await sess(admin, "PATCH", `/addresses/${C.addressId}`, { quota_bytes: 50_000_000 })).quota_bytes, 50_000_000)260 assert.equal((await stalwartAccount(C.address)).quotas.maxDiskQuota, 50_000_000)261 await sess(admin, "PATCH", `/addresses/${C.addressId}`, { quota_bytes: null })262 assert.equal((await stalwartAccount(C.address)).quotas.maxDiskQuota, undefined)263264 // création d'une boîte par une clé mail.admin (jamais par une clé ordinaire)265 const manage = await mkKey(admin, { scopes: ["mail.addresses.manage", "mail.aliases.manage", "mail.addresses.read"], addresses: [A.addressId] })266 const D = addr("created")267 await expectV1(manage.call("POST", "/addresses", { address: D, kind: "mailbox" }), 403, "admin_required")268 const adminKey = await mkKey(admin, { scopes: ["mail.admin"], all: true })269 const d = await adminKey.call("POST", "/addresses", { address: D, kind: "mailbox", display_name: "Créée par l'API" })270 assert.equal(d.kind, "mailbox")271 assert.ok(await stalwartAccount(D))272 await expectV1(adminKey.call("POST", "/addresses", { address: D, kind: "mailbox" }), 409, "address_taken")273 await expectV1(adminKey.call("POST", "/addresses", { address: "x@not-hosted.example", kind: "mailbox" }), 400, "unknown_domain")274 const kd = await mkKey(admin, { scopes: ["mail.send", "mail.read"], addresses: [d.id] })275276 // suspension d'une boîte : réception refusée par le serveur, envoi refusé par l'API ET par le serveur (passerelle JMAP comprise)277 const sus = await adminKey.call("PATCH", `/addresses/${d.id}`, { status: "suspended" })278 assert.equal(sus.inbound, "reject")279 assert.deepEqual(Object.keys((await stalwartAccount(D)).permissions.disabledPermissions).sort(), ["emailReceive", "jmapEmailSubmissionCreate"])280 const r = await sendAndWait(sendC, { from: C.address, to: [D], subject: "vers boîte suspendue", text: "x" })281 assert.equal(r.status, "bounced")282 assert.match(r.recipients[0].smtp_reply, /^550 5\.5\.0/)283 await expectV1(kd.call("POST", "/messages/send", { from: D, to: [C.address], subject: "x", text: "x" }), 403, "address_inactive")284 const [box] = await sql`select id from mailboxes where address = ${D}`285 const acct = (await admin.call("GET", `/api/jmap/${box.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]286 const idn = (await admin.jmap(box.id, [["Identity/get", { accountId: acct }, "i"]]))[0][1].list287 const viaGateway = await admin.jmap(box.id, [288 ["Email/set", { accountId: acct, create: { e: { mailboxIds: {}, from: [{ email: D }], to: [{ email: C.address }], subject: "contournement", bodyValues: { t: { value: "x" } }, textBody: [{ partId: "t", type: "text/plain" }] } } }, "e"],289 ["EmailSubmission/set", { accountId: acct, create: { s: { identityId: idn[0]?.id ?? "x", emailId: "#e" } } }, "s"]])290 assert.ok(!viaGateway[1][1].created, "le serveur de courrier refuse la soumission d'une boîte suspendue")291 // réactivation292 await adminKey.call("PATCH", `/addresses/${d.id}`, { status: "active" })293 assert.equal((await stalwartAccount(D)).permissions["@type"], "Inherit")294 assert.equal((await sendAndWait(kd, { from: D, to: [C.address], subject: "boîte réactivée", text: "x" })).status, "delivered")295296 // détachement (par défaut : le compte et son courrier restent), puis purge explicite et confirmée297 await sql`update sessions set reauth_at = null`298 await expectV1(sess(admin, "DELETE", `/addresses/${d.id}`, {}), 403, "reauth_required")299 await expectV1(manage.call("DELETE", `/addresses/${d.id}`, {}), 404, "not_found")300 assert.deepEqual(await adminKey.call("DELETE", `/addresses/${d.id}`, {}), { ok: true, purged: false })301 assert.ok(await stalwartAccount(D), "détaché : le compte de courrier existe toujours")302 assert.equal((await sql`select 1 from addresses where address = ${D}`).length, 0)303 await admin.call("POST", "/api/admin/mailboxes/adopt", { address: D })304 const again = await sess(admin, "GET", `/addresses/${D}`)305 await expectV1(adminKey.call("DELETE", `/addresses/${again.id}?purge=delete-all-mail`, {}), 400, "confirmation_required")306 assert.deepEqual(await adminKey.call("DELETE", `/addresses/${again.id}?purge=delete-all-mail`, { confirm: "delete-all-mail" }), { ok: true, purged: true })307 assert.equal(await stalwartAccount(D), null)308})309310test("clé de gestion d'alias : seulement dans les boîtes de sa liste, jamais de droit implicite sur l'adresse créée", async () => {311 const manage = await mkKey(admin, { scopes: ["mail.aliases.manage", "mail.addresses.read", "mail.send"], addresses: [A.addressId] })312 await expectV1(manage.call("POST", "/aliases", { address: addr("intrus"), mailbox: B.address }), 403, "address_not_allowed")313 const al = await manage.call("POST", "/aliases", { address: addr("agent"), mailbox: A.address, kind: "notification" })314 assert.equal(al.kind, "notification")315 await expectV1(manage.call("PATCH", `/aliases/${al.id}`, { protected: true }), 404) // hors de sa liste : invisible316 await expectV1(manage.call("POST", "/messages/send", { from: addr("agent"), to: [B.address], subject: "x", text: "x" }), 403, "from_not_allowed")317 assert.ok(!(await manage.call("GET", "/addresses")).data.some((a: any) => a.address === addr("agent")))318 // une fois l'adresse ajoutée à sa liste par un administrateur, la clé peut la gérer319 await reauth(admin)320 await admin.call("PATCH", `/api/admin/api-keys/${manage.id}`, { address_ids: [A.addressId, al.id] })321 assert.equal((await manage.call("PATCH", `/aliases/${al.id}`, { display_name: "Agent" })).display_name, "Agent")322 await expectV1(manage.call("PATCH", `/aliases/${al.id}`, { protected: true }), 403, "admin_required")323 await expectV1(manage.call("PATCH", `/aliases/${al.id}`, { kind: "mailbox" }), 400, "kind_change_unsupported")324 await expectV1(manage.call("PATCH", `/addresses/${A.addressId}`, { status: "suspended" }), 403, "admin_required")325 assert.deepEqual(await manage.call("DELETE", `/aliases/${al.id}`), { ok: true, purged: false })326})327328test("automatisation : règles + réexpédition dans UN script « spmail », compatible avec le webmail ; bloc du serveur réinjecté", async () => {329 const ka = await mkKey(admin, { scopes: ["mail.addresses.manage", "mail.addresses.read", "mail.read"], addresses: [A.addressId] })330 const empty = await ka.call("GET", `/addresses/${A.addressId}/automation`)331 assert.deepEqual(empty.rules, [])332 assert.equal(empty.raw_sieve, undefined, "le script brut n'est rendu qu'aux administrateurs")333 await expectV1(ka.call("PUT", `/addresses/${A.addressId}/automation`, { raw_sieve: "keep;" }), 403, "insufficient_scope")334 await expectV1(ka.call("PUT", `/addresses/${A.addressId}/automation`, { forward: { to: "someone@example.org" } }), 400, "forward_not_local")335 await expectV1(ka.call("PUT", `/addresses/${POSTMASTER}/automation`, { rules: [] }), 404)336 const rule = { id: "r1", name: "Factures", enabled: true, match: "all", conditions: [{ field: "subject", op: "contains", value: "facture" }], actions: [{ type: "move", folder: "Factures" }, { type: "flag" }] }337 const put = await ka.call("PUT", `/addresses/${A.addressId}/automation`, { rules: [rule], vacation: { enabled: false, subject: "", text: "" }, forward: { to: C.address, keep_copy: true } })338 assert.equal(put.managed, true)339 assert.equal(put.active, true)340 assert.deepEqual(put.forward, { to: C.address, keep_copy: true })341 assert.equal(put.rules[0].name, "Factures")342 const raw = (await sess(admin, "GET", `/addresses/${A.addressId}/automation`)).raw_sieve as string343 assert.match(raw, /# spmail-config: /)344 assert.match(raw, /# spmail-policy:begin[\s\S]*redirect :copy/)345 // effet réel : classé dans « Factures », marqué, et copie réexpédiée à C346 assert.equal((await sendAndWait(sendB, { from: B.address, to: [A.address], subject: "facture 2026-11", text: "x" })).status, "delivered")347 const filed = await until(async () => (await readA.call("GET", "/messages?subject=facture")).data.find((m: any) => m.subject === "facture 2026-11"), "message classé")348 assert.deepEqual(filed.folders.map((f: any) => f.name), ["Factures"])349 assert.equal(filed.starred, true)350 await arrives(readC, "facture 2026-11")351 // le webmail réécrit le script (sans le bloc du serveur) par la passerelle JMAP : le serveur le réinjecte352 const acct = (await admin.call("GET", `/api/jmap/${A.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]353 const plain = raw.replace(/# spmail-policy:begin[\s\S]*# spmail-policy:end\r\n/, "")354 assert.ok(!plain.includes("redirect"))355 const up = await admin.raw("POST", `/api/jmap/${A.id}/upload/${acct}/`, new Uint8Array(Buffer.from(plain)), { "content-type": "application/sieve" })356 const blob = (await up.json()) as { blobId: string }357 const scripts = (await admin.jmap(A.id, [["SieveScript/get", { accountId: acct }, "g"]], ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:sieve"]))[0][1].list358 const sid = scripts.find((s: any) => s.name === "spmail").id359 const set = await admin.jmap(A.id, [["SieveScript/set", { accountId: acct, update: { [sid]: { blobId: blob.blobId } }, onSuccessActivateScript: sid }, "s"]], ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:sieve"])360 assert.ok(set[0][1].updated)361 await until(async () => /spmail-policy:begin/.test((await sess(admin, "GET", `/addresses/${A.addressId}/automation`)).raw_sieve), "bloc de politique réinjecté")362 // script brut (administrateur) : validé par le serveur de courrier363 await expectV1(sess(admin, "PUT", `/addresses/${A.addressId}/automation`, { raw_sieve: "this is not sieve" }), 400, "invalid_sieve")364 // retour à un état sans automatisation365 const off = await ka.call("PUT", `/addresses/${A.addressId}/automation`, { rules: [], forward: null })366 assert.equal(off.forward, null)367 assert.ok(!/redirect/.test((await sess(admin, "GET", `/addresses/${A.addressId}/automation`)).raw_sieve))368})369370test("boîte partagée : droits de lecture puis d'envoi accordés à un autre utilisateur (passerelle JMAP, /api/me, /api/v1)", async () => {371 const member = new Client("web")372 await member.enroll(tokenOf(await cli("invite")), "membre", "Membre")373 const m = (await admin.call("GET", "/api/admin/users")).find((u: any) => u.handle === "membre")374 await rejects(member.call("GET", `/api/jmap/${B.id}/session`), 404)375 await sql`update sessions set reauth_at = null`376 await rejects(admin.call("PUT", `/api/admin/mailboxes/${B.id}/grants`, { grants: [{ user_id: m.id }] }), 403, "reauth_required")377 await reauth(admin)378 await admin.call("PUT", `/api/admin/mailboxes/${B.id}/grants`, { grants: [{ user_id: m.id, can_read: true, can_send: false }] })379 assert.equal((await sess(admin, "GET", `/addresses/${B.addressId}`)).kind, "shared")380 const me = await member.call("GET", "/api/me")381 assert.deepEqual(me.mailboxes.map((b: any) => [b.address, b.access, b.can_send]), [[B.address, "shared", false]])382 assert.equal((await admin.call("GET", "/api/me")).mailboxes.find((b: any) => b.address === B.address).access, "owner")383 // lecture par la passerelle et par /api/v1 ; aucune soumission384 const acct = (await member.call("GET", `/api/jmap/${B.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]385 assert.equal((await member.jmap(B.id, [["Mailbox/get", { accountId: acct, properties: ["role"] }, "m"]]))[0][0], "Mailbox/get")386 await rejects(member.jmap(B.id, [["EmailSubmission/set", { accountId: acct, create: {} }, "s"]]), 403, "send_not_granted")387 assert.ok((await sess(member, "GET", "/messages")).data.every((x: any) => x.mailbox === B.address))388 await expectV1(sess(member, "POST", "/messages/send", { from: B.address, to: [C.address], subject: "x", text: "x" }), 403, "from_not_allowed")389 await expectV1(sess(member, "GET", `/messages?address=${A.address}`), 403, "address_not_allowed")390 await expectV1(sess(member, "POST", "/aliases", { address: addr("m"), mailbox: B.address }), 403, "admin_required")391 // droit d'envoi accordé392 await admin.call("PUT", `/api/admin/mailboxes/${B.id}/grants`, { grants: [{ user_id: m.id, can_read: true, can_send: true }] })393 const sent = await sess(member, "POST", "/messages/send", { from: B.address, to: [C.address], subject: "envoi partagé", text: "x" })394 assert.equal(sent.status, "sent")395 await arrives(readC, "envoi partagé")396 // retrait du partage397 await admin.call("PUT", `/api/admin/mailboxes/${B.id}/grants`, { grants: [] })398 await rejects(member.call("GET", `/api/jmap/${B.id}/session`), 404)399 assert.deepEqual((await sess(member, "GET", "/messages")).data, [])400 assert.equal((await sess(admin, "GET", `/addresses/${B.addressId}`)).kind, "mailbox")401})402403test("conservation : opt-in par adresse, journalisée ; rien n'est supprimé par défaut", async () => {404 const acct = (await admin.call("GET", `/api/jmap/${C.id}/session`)).primaryAccounts["urn:ietf:params:jmap:mail"]405 const boxes = Object.fromEntries((await admin.jmap(C.id, [["Mailbox/get", { accountId: acct, properties: ["role"] }, "m"]]))[0][1].list.map((b: any) => [b.role, b.id]))406 const mk = (subject: string, box: string, daysAgo: number) => ({ mailboxIds: { [box]: true }, receivedAt: new Date(Date.now() - daysAgo * 86400_000).toISOString().replace(/\.\d+Z$/, "Z"), from: [{ email: B.address }], to: [{ email: C.address }], subject, bodyValues: { t: { value: "x" } }, textBody: [{ partId: "t", type: "text/plain" }] })407 const cr = await admin.jmap(C.id, [["Email/set", { accountId: acct, create: { a: mk("corbeille ancienne", boxes.trash, 10), b: mk("corbeille récente", boxes.trash, 1), c: mk("réception ancienne", boxes.inbox, 400) } }, "c"]])408 assert.equal(Object.keys(cr[0][1].created).length, 3)409 const subjects = async () => (await readC.call("GET", "/messages?limit=100")).data.map((m: any) => m.subject)410 // par défaut (durées nulles) : un passage ne supprime rien411 await reauth(admin)412 assert.deepEqual((await admin.call("POST", "/api/admin/retention/run", {})).report, [])413 assert.ok((await subjects()).includes("corbeille ancienne"))414 // opt-in : corbeille de plus de 7 jours415 await sess(admin, "PATCH", `/addresses/${C.addressId}`, { retention_trash_days: 7 })416 const run = await admin.call("POST", "/api/admin/retention/run", {})417 assert.deepEqual(run.report, [{ mailbox: C.address, deleted: { trash: 1 } }])418 const left = await subjects()419 assert.ok(!left.includes("corbeille ancienne") && left.includes("corbeille récente") && left.includes("réception ancienne"))420 // toute la boîte au-delà d'un an421 await sess(admin, "PATCH", `/addresses/${C.addressId}`, { retention_trash_days: null, retention_days: 365 })422 assert.deepEqual((await admin.call("POST", "/api/admin/retention/run", {})).report, [{ mailbox: C.address, deleted: { all: 1 } }])423 assert.ok(!(await subjects()).includes("réception ancienne"))424 await sess(admin, "PATCH", `/addresses/${C.addressId}`, { retention_days: null })425 const log = await admin.call("GET", "/api/admin/audit")426 assert.ok(log.some((l: any) => l.action === "retention.run" && l.target === C.address && l.meta.deleted.trash === 1))427})428