SPB Git

Repository Public

v1-addresses.test.ts 31.9 KB 428 lines typescript

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
Files main
Menu

Theme