Repository Public
1import assert from "node:assert/strict"2import { test } from "node:test"3import { enAdmKeys } from "../i18n/en.adm.keys"4import { frAdmKeys } from "../i18n/fr.adm.keys"5import {6 FormInvalid, GRACE_CHOICES, LIMITS, PRESETS, PRESET_IDS, SCOPES, SCOPE_GROUPS, STEPS, applyPreset, canSend, defaultCallFilter, detectPreset, diffPayload, emptyForm, expiryToIso, filterCalls,7 firstInvalidStep, formErrorKey, formFromKey, isExternal, isGrace, methodsOf, normalizeScopes, parseDomains, parseIntIn, presetDescKey, presetLabelKey, scopeDescKey,8 scopeGroupKey, scopeLabelKey, statusClass, toPayload, toggleScope, validateForm, validateStep, type FormError, type KeyForm, type KeyLike, type UsageCall,9} from "./scopes"1011const NOW = new Date("2026-11-19T15:00:00Z")12const A1 = "11111111-1111-4111-8111-111111111111"13const A2 = "22222222-2222-4222-8222-222222222222"14const valid = (over: Partial<KeyForm> = {}): KeyForm => ({ ...emptyForm(), name: "agent-alertes", scopes: ["mail.send"], addressIds: [A1], ...over })1516test("portées : le catalogue est celui du serveur, chaque portée est rangée dans un seul groupe", () => {17 assert.equal(SCOPES.length, 13)18 const grouped = SCOPE_GROUPS.flatMap((g) => [...g.scopes])19 assert.deepEqual([...grouped].sort(), [...SCOPES].sort())20 assert.equal(new Set(grouped).size, grouped.length)21})2223test("portées : chaque portée, groupe, profil et erreur a son texte en langage clair, en français et en anglais", () => {24 const fr = frAdmKeys as Record<string, string>25 const en = enAdmKeys as Record<string, string>26 const errors: FormError[] = ["name_required", "name_too_long", "description_too_long", "scopes_required", "addresses_required", "too_many_addresses", "all_requires_admin", "domains_invalid", "too_many_domains", "rate_invalid", "daily_invalid", "expiry_invalid", "expiry_past"]27 const keys = [...SCOPES.flatMap((s) => [scopeLabelKey(s), scopeDescKey(s)]), ...SCOPE_GROUPS.map((g) => scopeGroupKey(g.id)), ...PRESET_IDS.flatMap((p) => [presetLabelKey(p), presetDescKey(p)]), ...errors.map(formErrorKey)]28 for (const k of keys) {29 assert.ok(fr[k]?.trim(), `fr : ${k}`)30 assert.ok(en[k]?.trim(), `en : ${k}`)31 }32 assert.deepEqual(Object.keys(en).sort(), Object.keys(fr).sort())33})3435test("profils : les cinq profils demandés, avec leurs portées", () => {36 assert.deepEqual(PRESETS.map((p) => p.id), ["send_only", "read_only", "agent_drafts", "agent_send_approval", "admin"])37 const by = Object.fromEntries(PRESETS.map((p) => [p.id, p]))38 assert.deepEqual(by.send_only.scopes, ["mail.send"])39 assert.ok(!canSend(by.read_only.scopes) && !canSend(by.agent_drafts.scopes))40 assert.ok(by.agent_drafts.scopes.includes("mail.drafts") && by.agent_drafts.scopes.includes("mail.read"))41 assert.ok(canSend(by.agent_send_approval.scopes))42 assert.equal(by.agent_send_approval.policy, "approval")43 assert.deepEqual(by.admin.scopes, ["mail.admin"])44 // aucun profil n'ouvre l'envoi externe sans approbation, aucun profil non administrateur ne supprime ni n'administre45 for (const p of PRESETS) {46 assert.notEqual(p.policy, "allow")47 if (p.id !== "admin") for (const s of ["mail.delete", "mail.admin", "mail.addresses.manage", "mail.aliases.manage"]) assert.ok(!(p.scopes as readonly string[]).includes(s), `${p.id} ${s}`)48 }49})5051test("profils : détection depuis une liste de portées (ordre et doublons indifférents)", () => {52 for (const p of PRESETS) assert.equal(detectPreset([...p.scopes].reverse()), p.id)53 assert.equal(detectPreset(["mail.send", "mail.send"]), "send_only")54 assert.equal(detectPreset(["mail.send", "mail.read"]), "custom")55 assert.equal(detectPreset([]), "custom")56 assert.equal(detectPreset(["mail.send", "mail.unknown"]), "custom")57 assert.equal(detectPreset(["mail.admin", "mail.send"]), "custom")58})5960test("portées : normalisation (ordre du catalogue, inconnues et doublons retirés)", () => {61 assert.deepEqual(normalizeScopes(["mail.read", "x", "mail.send", "mail.read"]), ["mail.send", "mail.read"])62})6364test("formulaire : appliquer un profil, cocher et décocher ; retirer mail.admin retire « toutes les adresses »", () => {65 let f = applyPreset({ ...emptyForm(), allAddresses: true }, "admin")66 assert.deepEqual(f.scopes, ["mail.admin"])67 assert.equal(f.allAddresses, true)68 f = toggleScope(f, "mail.admin", false)69 assert.equal(f.allAddresses, false)70 f = toggleScope(f, "mail.read", true)71 f = toggleScope(f, "mail.send", true)72 assert.deepEqual(f.scopes, ["mail.send", "mail.read"])73 f = applyPreset({ ...f, allAddresses: true }, "send_only")74 assert.equal(f.allAddresses, false)75 assert.equal(f.policy, "approval")76 assert.equal(applyPreset(emptyForm(), "read_only").policy, "deny")77})7879test("formulaire : « toutes les adresses » exige mail.admin ; sans adresse, rien d'implicite", () => {80 assert.deepEqual(validateStep("addresses", valid({ allAddresses: true, addressIds: [] })), ["all_requires_admin"])81 assert.deepEqual(validateStep("addresses", valid({ allAddresses: true, addressIds: [], scopes: ["mail.admin"] })), [])82 assert.deepEqual(validateStep("addresses", valid({ addressIds: [] })), ["addresses_required"])83 assert.deepEqual(validateStep("addresses", valid({ addressIds: [] }), { allowEmptyAddresses: true }), [])84 assert.deepEqual(validateStep("addresses", valid({ addressIds: [], scopes: ["mail.admin"] })), ["addresses_required"])85 assert.throws(() => toPayload(valid({ allAddresses: true }), { now: NOW }), (e) => e instanceof FormInvalid && e.errors.includes("all_requires_admin"))86})8788test("formulaire : charge utile complète et explicite", () => {89 const p = toPayload(valid({ name: " agent-alertes ", description: " Alertes ", scopes: ["mail.read", "mail.send", "mail.send"], addressIds: [A1, A1, A2], policy: "deny", domains: "Example.org, @exemple.ca\nexample.org", rate: " 120 ", daily: "0" }), { now: NOW })90 assert.deepEqual(p, {91 name: "agent-alertes", description: "Alertes", scopes: ["mail.send", "mail.read"], address_ids: [A1, A2], all_addresses: false, rate_per_minute: 120, daily_send_limit: 0,92 external_send_policy: "deny", allowed_recipient_domains: ["example.org", "exemple.ca"], expires_at: null,93 })94 // « toutes les adresses » : choix explicite, la liste nominative n'est pas envoyée en double95 const all = toPayload(valid({ scopes: ["mail.admin"], allAddresses: true, addressIds: [A1] }), { now: NOW })96 assert.equal(all.all_addresses, true)97 assert.deepEqual(all.address_ids, [])98})99100test("formulaire : erreurs par étape et première étape fautive", () => {101 assert.deepEqual(validateStep("identity", emptyForm()), ["name_required"])102 assert.deepEqual(validateStep("identity", valid({ name: "x".repeat(81) })), ["name_too_long"])103 assert.deepEqual(validateStep("identity", valid({ description: "x".repeat(501) })), ["description_too_long"])104 assert.deepEqual(validateStep("scopes", valid({ scopes: [] })), ["scopes_required"])105 assert.deepEqual(validateStep("policy", valid({ domains: "ok.example, pas un domaine!, x" })), ["domains_invalid"])106 assert.deepEqual(validateStep("policy", valid({ domains: Array.from({ length: 101 }, (_, i) => `d${i}.example`).join(" ") })), ["too_many_domains"])107 assert.deepEqual(validateStep("limits", valid({ rate: "0", daily: "100001" })), ["rate_invalid", "daily_invalid"])108 assert.deepEqual(validateStep("limits", valid({ rate: "6000", daily: "100000" })), [])109 assert.deepEqual(validateStep("limits", valid({ rate: "1.5", daily: "-1" })), ["rate_invalid", "daily_invalid"])110 assert.deepEqual(validateForm(valid(), { now: NOW }), [])111 assert.equal(firstInvalidStep(valid(), { now: NOW }), null)112 assert.equal(firstInvalidStep(valid({ rate: "" }), { now: NOW }), "limits")113 assert.equal(firstInvalidStep(emptyForm(), { now: NOW }), "identity")114 assert.equal(STEPS[STEPS.length - 1], "review")115})116117test("limites : entiers stricts", () => {118 assert.equal(parseIntIn("60", 1, 6000), 60)119 assert.equal(parseIntIn(" 1 ", 1, 6000), 1)120 for (const bad of ["", "abc", "1e3", "12.0", "-5", "+5", "6001", "0x10", "9999999999"]) assert.equal(parseIntIn(bad, 1, 6000), null, bad)121})122123test("domaines : normalisation et entrées refusées", () => {124 assert.deepEqual(parseDomains(""), { domains: [], invalid: [] })125 assert.deepEqual(parseDomains(" A.Example ; b.example,a.example "), { domains: ["a.example", "b.example"], invalid: [] })126 assert.deepEqual(parseDomains("localhost .example.org ex_ample.org user@example.org").domains, [])127 assert.equal(parseDomains("localhost .example.org ex_ample.org user@example.org").invalid.length, 4)128})129130test("échéance : jamais, durée, date (fin de journée locale), passée, invalide, conservée", () => {131 assert.deepEqual(expiryToIso({ expiry: "never", expiryDate: "", currentExpiry: null }, NOW), { ok: true, iso: null })132 assert.deepEqual(expiryToIso({ expiry: "90", expiryDate: "", currentExpiry: null }, NOW), { ok: true, iso: "2027-02-17T15:00:00.000Z" })133 const d = expiryToIso({ expiry: "date", expiryDate: "2027-01-31", currentExpiry: null }, NOW)134 assert.ok(d.ok && d.iso !== null)135 const end = new Date((d as { iso: string }).iso)136 assert.deepEqual([end.getFullYear(), end.getMonth(), end.getDate(), end.getHours(), end.getMinutes()], [2027, 0, 31, 23, 59])137 assert.deepEqual(expiryToIso({ expiry: "date", expiryDate: "2020-01-01", currentExpiry: null }, NOW), { ok: false, error: "expiry_past" })138 for (const bad of ["", "31/01/2027", "2027-02-30", "2027-13-01"]) assert.deepEqual(expiryToIso({ expiry: "date", expiryDate: bad, currentExpiry: null }, NOW), { ok: false, error: "expiry_invalid" }, bad)139 assert.deepEqual(expiryToIso({ expiry: "keep", expiryDate: "", currentExpiry: "2027-05-01T00:00:00.000Z" }, NOW), { ok: true, iso: "2027-05-01T00:00:00.000Z" })140 assert.deepEqual(validateStep("limits", valid({ expiry: "date", expiryDate: "2020-01-01" }), { now: NOW }), ["expiry_past"])141})142143const KEY: KeyLike = {144 name: "agent", description: "", scopes: ["mail.read", "mail.send"], address_ids: [A1, A2], all_addresses: false, rate_per_minute: 60, daily_send_limit: 200,145 external_send_policy: "approval", allowed_recipient_domains: ["example.org"], expires_at: "2027-05-01T00:00:00.000Z",146}147148test("modification : une clé relue sans changement ne produit aucun champ", () => {149 const f = formFromKey(KEY)150 assert.equal(f.expiry, "keep")151 assert.deepEqual(diffPayload(KEY, toPayload(f, { now: NOW, allowEmptyAddresses: true })), {})152 assert.equal(formFromKey({ ...KEY, expires_at: null }).expiry, "never")153})154155test("modification : seuls les champs changés partent dans le PATCH", () => {156 const f = { ...formFromKey(KEY), name: "agent-2", addressIds: [A2], policy: "deny" as const, expiry: "never" as const }157 assert.deepEqual(diffPayload(KEY, toPayload(f, { now: NOW })), { name: "agent-2", address_ids: [A2], external_send_policy: "deny", expires_at: null })158 // l'ordre des listes n'est pas un changement159 const g = { ...formFromKey(KEY), addressIds: [A2, A1], scopes: normalizeScopes(["mail.send", "mail.read"]) }160 assert.deepEqual(diffPayload(KEY, toPayload(g, { now: NOW })), {})161 // une clé « toutes les adresses » qui perd mail.admin : les deux champs partent ensemble, et il faut choisir des adresses162 const adminKey: KeyLike = { ...KEY, scopes: ["mail.admin"], all_addresses: true, address_ids: [] }163 const h = toggleScope(toggleScope(formFromKey(adminKey), "mail.admin", false), "mail.read", true)164 assert.deepEqual(validateStep("addresses", h), ["addresses_required"])165 assert.deepEqual(diffPayload(adminKey, toPayload({ ...h, addressIds: [A1] }, { now: NOW })), { scopes: ["mail.read"], address_ids: [A1], all_addresses: false })166})167168test("modification : une clé créée ailleurs avec « toutes les adresses » sans mail.admin n'est pas présentée comme telle", () => {169 assert.equal(formFromKey({ ...KEY, all_addresses: true }).allAddresses, false)170})171172test("rotation : délais de grâce proposés, bornés à 7 jours", () => {173 assert.equal(GRACE_CHOICES[0], 0)174 assert.ok(GRACE_CHOICES.every((g) => g >= 0 && g <= LIMITS.graceMax))175 assert.ok(isGrace(86400) && !isGrace(5))176})177178const call = (over: Partial<UsageCall>): UsageCall => ({ at: "2026-11-19T14:00:00Z", method: "GET", route: "/api/v1/me", status: 200, duration_ms: 4, ip: "127.0.0.1", error_code: null, explorer: false, ...over })179const CALLS = [180 call({}),181 call({ method: "POST", route: "/api/v1/messages/send", status: 202 }),182 call({ status: 403, error_code: "insufficient_scope" }),183 call({ status: 500 }),184 call({ explorer: true }),185 call({ at: "2026-11-01T00:00:00Z" }),186]187188test("journal : classes d'état", () => {189 assert.deepEqual([200, 202, 304, 401, 404, 429, 500, 503].map(statusClass), ["2xx", "2xx", "3xx", "4xx", "4xx", "4xx", "5xx", "5xx"])190})191192test("journal : filtres (période, classe d'état, méthode, explorateur) combinés", () => {193 assert.equal(filterCalls(CALLS, defaultCallFilter(7), NOW).length, 5)194 assert.equal(filterCalls(CALLS, defaultCallFilter(30), NOW).length, 6)195 assert.equal(filterCalls(CALLS, { ...defaultCallFilter(30), status: "2xx" }, NOW).length, 4)196 assert.deepEqual(filterCalls(CALLS, { ...defaultCallFilter(7), status: "4xx" }, NOW).map((c) => c.error_code), ["insufficient_scope"])197 assert.equal(filterCalls(CALLS, { ...defaultCallFilter(7), status: "5xx" }, NOW).length, 1)198 assert.deepEqual(filterCalls(CALLS, { ...defaultCallFilter(7), method: "post" }, NOW).map((c) => c.route), ["/api/v1/messages/send"])199 assert.equal(filterCalls(CALLS, { ...defaultCallFilter(7), explorer: "only" }, NOW).length, 1)200 assert.equal(filterCalls(CALLS, { ...defaultCallFilter(7), explorer: "without" }, NOW).length, 4)201 assert.equal(filterCalls(CALLS, { days: 7, status: "2xx", method: "GET", explorer: "without" }, NOW).length, 1)202 assert.deepEqual(methodsOf(CALLS), ["GET", "POST"])203})204205test("approbations : destinataires externes repérés sans tenir compte de la casse", () => {206 assert.equal(isExternal("Client@Example.org", ["client@example.org"]), true)207 assert.equal(isExternal("moi@stg.spboucher.ai", ["client@example.org"]), false)208 assert.equal(isExternal("a@b.c", []), false)209})210