Promemoria senza ritorni e tre canali per ogni notifica (DD-037, DD-038)
m23: un registro (promemoria_eventi_generati) ricorda i promemoria a 24 e 3 ore già generati, così eliminare la notifica non li fa rigenerare dal cron né riaccodare la mail a ogni giro. m24: la push dei promemoria, che nascono nel database, la manda il worker mailer/ con lo stesso modulo dell'app (coda notifiche_push_coda, esiti, backoff, iscrizioni scadute eliminate, push scartate oltre 3 ore). Il sondaggio pre-partita scrive anche notifiche_utente (tipo sondaggio_cacche): compare in-app e arriva per email. L'immagine del worker si costruisce dalla radice del repository per includere src/lib/webpush.server.ts. Test: 9 di integrazione per m23, 17 per la coda push, 6 per la route del sondaggio, nuovi casi unitari sul worker; prova end-to-end con un servizio push finto. Documentazione e catalogo delle notifiche aggiornati. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
davideandClaude Sonnet 5.5 committed
1 parent
58eba642f7
commit
e9013b703b
27 files changed
+2076
-92
No files matched your search
@@ -0,0 +1,225 @@
|
||||
/**
|
||||
* Promemoria evento che non ricompaiono (M23, DD-037): `bun test/integration/promemoria-eventi.test.ts`.
|
||||
*
|
||||
* Prima di M23 l'unica traccia che un promemoria fosse già stato generato era la riga in
|
||||
* `notifiche_utente`: eliminarla dal centro notifiche faceva rigenerare il promemoria (e
|
||||
* riaccodare la mail) al giro successivo del job. Qui si verifica che il registro
|
||||
* `promemoria_eventi_generati` lo eviti, senza rompere la generazione normale.
|
||||
*
|
||||
* Gira solo sullo stack locale (`npx supabase start`). Usa eventi con il prefisso
|
||||
* `test-promemoria-eventi` e gli slot `g4`, `g5`, `g6` della rosa seed come convocati; non
|
||||
* serve un account collegato perché le notifiche si eliminano con la service role.
|
||||
*/
|
||||
import assert from "node:assert/strict";
|
||||
import { statoLocale } from "../helpers/locale";
|
||||
import { prova, riepilogo, salta } from "../helpers/prova";
|
||||
|
||||
const locale = statoLocale();
|
||||
|
||||
if (!locale) {
|
||||
salta("promemoria eventi", "stack locale non attivo (npx supabase start)");
|
||||
riepilogo("promemoria-eventi");
|
||||
} else {
|
||||
const { url: URL_BASE, anon: ANON, servizio: SERVIZIO } = locale;
|
||||
console.log(`promemoria eventi su ${URL_BASE}`);
|
||||
|
||||
const PREFISSO = "test-promemoria-eventi";
|
||||
const EVENTO = `${PREFISSO}-a`;
|
||||
const EVENTO_LONTANO = `${PREFISSO}-lontano`;
|
||||
const EVENTO_CASCATA = `${PREFISSO}-cascata`;
|
||||
const G4 = "g4";
|
||||
const G5 = "g5";
|
||||
const G6 = "g6";
|
||||
|
||||
const rest = (percorso: string, token: string, init?: RequestInit) =>
|
||||
fetch(`${URL_BASE}/rest/v1/${percorso}`, {
|
||||
...init,
|
||||
headers: {
|
||||
apikey: token === SERVIZIO ? SERVIZIO : ANON,
|
||||
Authorization: `Bearer ${token}`,
|
||||
"content-type": "application/json",
|
||||
...(init?.headers ?? {}),
|
||||
},
|
||||
});
|
||||
|
||||
async function leggi<T>(percorso: string): Promise<T[]> {
|
||||
const res = await rest(percorso, SERVIZIO);
|
||||
if (!res.ok) throw new Error(`select su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
return (await res.json()) as T[];
|
||||
}
|
||||
|
||||
async function scrivi(percorso: string, metodo: string, corpo?: unknown) {
|
||||
const res = await rest(percorso, SERVIZIO, {
|
||||
method: metodo,
|
||||
body: corpo === undefined ? null : JSON.stringify(corpo),
|
||||
});
|
||||
if (!res.ok) throw new Error(`${metodo} su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
|
||||
async function cron(tipo: "evento_promemoria_24h" | "evento_promemoria_3h") {
|
||||
const res = await fetch(`${URL_BASE}/rest/v1/rpc/genera_promemoria_eventi`, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
apikey: SERVIZIO,
|
||||
Authorization: `Bearer ${SERVIZIO}`,
|
||||
"content-type": "application/json",
|
||||
},
|
||||
body: JSON.stringify({
|
||||
p_tipo: tipo,
|
||||
p_finestra: tipo === "evento_promemoria_24h" ? "24 hours" : "3 hours",
|
||||
}),
|
||||
});
|
||||
if (!res.ok) throw new Error(`genera_promemoria_eventi: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
|
||||
/** Data e ora dell'inizio tra `ore` ore, nel fuso Europe/Rome (convenzione di `eventi_app`). */
|
||||
function tra(ore: number): { data: string; ora: string } {
|
||||
const quando = new Date(Date.now() + ore * 60 * 60 * 1000);
|
||||
const data = new Intl.DateTimeFormat("en-CA", { timeZone: "Europe/Rome" }).format(quando);
|
||||
const ora = new Intl.DateTimeFormat("it-IT", {
|
||||
timeZone: "Europe/Rome",
|
||||
hour: "2-digit",
|
||||
minute: "2-digit",
|
||||
hour12: false,
|
||||
}).format(quando);
|
||||
return { data, ora };
|
||||
}
|
||||
|
||||
const notifiche = (evento: string, tipo: string) =>
|
||||
leggi<{ id: string; giocatore_id: string; letta: boolean }>(
|
||||
`notifiche_utente?evento_id=eq.${evento}&tipo=eq.${tipo}&select=id,giocatore_id,letta&order=giocatore_id`,
|
||||
);
|
||||
const registro = (evento: string, tipo?: string) =>
|
||||
leggi<{ giocatore_id: string; tipo: string }>(
|
||||
`promemoria_eventi_generati?evento_id=eq.${evento}${tipo ? `&tipo=eq.${tipo}` : ""}&select=giocatore_id,tipo`,
|
||||
);
|
||||
const inCoda = async (ids: string[]) =>
|
||||
ids.length === 0
|
||||
? []
|
||||
: leggi<{ notifica_id: string }>(
|
||||
`notifiche_email_coda?notifica_id=in.(${ids.join(",")})&select=notifica_id`,
|
||||
);
|
||||
|
||||
try {
|
||||
await scrivi("eventi_app", "POST", {
|
||||
id: EVENTO,
|
||||
tipo: "allenamento",
|
||||
titolo: `${PREFISSO} evento`,
|
||||
...tra(2),
|
||||
convocati: [G4, G5],
|
||||
});
|
||||
await scrivi("eventi_app", "POST", {
|
||||
id: EVENTO_LONTANO,
|
||||
tipo: "allenamento",
|
||||
titolo: `${PREFISSO} lontano`,
|
||||
...tra(72),
|
||||
convocati: [G4],
|
||||
});
|
||||
|
||||
await prova("il job genera il promemoria per i convocati e lo registra", async () => {
|
||||
await cron("evento_promemoria_24h");
|
||||
const n = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
assert.deepEqual(
|
||||
n.map((r) => r.giocatore_id),
|
||||
[G4, G5],
|
||||
);
|
||||
assert.equal((await registro(EVENTO, "evento_promemoria_24h")).length, 2);
|
||||
});
|
||||
|
||||
await prova("un secondo giro del job non duplica né riaccoda", async () => {
|
||||
const prima = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
const codaPrima = await inCoda(prima.map((r) => r.id));
|
||||
await cron("evento_promemoria_24h");
|
||||
const dopo = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
assert.deepEqual(
|
||||
dopo.map((r) => r.id),
|
||||
prima.map((r) => r.id),
|
||||
);
|
||||
assert.equal((await inCoda(dopo.map((r) => r.id))).length, codaPrima.length);
|
||||
});
|
||||
|
||||
await prova(
|
||||
"eliminata la notifica, il promemoria NON ricompare al giro successivo",
|
||||
async () => {
|
||||
const [mia] = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
assert.ok(mia);
|
||||
await scrivi(`notifiche_utente?id=eq.${mia.id}`, "DELETE");
|
||||
assert.equal((await notifiche(EVENTO, "evento_promemoria_24h")).length, 1);
|
||||
|
||||
await cron("evento_promemoria_24h");
|
||||
await cron("evento_promemoria_24h");
|
||||
const dopo = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
assert.equal(dopo.length, 1, "solo la notifica dell'altro convocato, non quella eliminata");
|
||||
assert.ok(!dopo.some((r) => r.giocatore_id === mia.giocatore_id));
|
||||
},
|
||||
);
|
||||
|
||||
await prova("nessuna nuova mail in coda per il promemoria eliminato", async () => {
|
||||
const righe = await leggi<{ id: string; giocatore_id: string }>(
|
||||
`notifiche_utente?evento_id=eq.${EVENTO}&tipo=eq.evento_promemoria_24h&select=id,giocatore_id`,
|
||||
);
|
||||
const coda = await inCoda(righe.map((r) => r.id));
|
||||
assert.equal(coda.length, righe.length, "una sola riga in coda per notifica rimasta");
|
||||
});
|
||||
|
||||
await prova("il promemoria a 3 ore è indipendente da quello a 24 ore", async () => {
|
||||
await cron("evento_promemoria_3h");
|
||||
const n = await notifiche(EVENTO, "evento_promemoria_3h");
|
||||
assert.equal(n.length, 2, "l'evento parte tra 2 ore: rientra nella finestra di 3");
|
||||
const [mia] = n;
|
||||
assert.ok(mia);
|
||||
await scrivi(`notifiche_utente?id=eq.${mia.id}`, "DELETE");
|
||||
await cron("evento_promemoria_3h");
|
||||
assert.equal((await notifiche(EVENTO, "evento_promemoria_3h")).length, 1);
|
||||
});
|
||||
|
||||
await prova("un convocato aggiunto dopo riceve comunque il suo promemoria", async () => {
|
||||
await scrivi(`eventi_app?id=eq.${EVENTO}`, "PATCH", { convocati: [G4, G5, G6] });
|
||||
await cron("evento_promemoria_24h");
|
||||
const n = await notifiche(EVENTO, "evento_promemoria_24h");
|
||||
assert.ok(
|
||||
n.some((r) => r.giocatore_id === G6),
|
||||
"g6 ha ricevuto il promemoria",
|
||||
);
|
||||
assert.equal(n.filter((r) => r.giocatore_id === G6).length, 1);
|
||||
});
|
||||
|
||||
await prova("un evento fuori dalla finestra non genera né registra nulla", async () => {
|
||||
await cron("evento_promemoria_24h");
|
||||
await cron("evento_promemoria_3h");
|
||||
assert.equal((await notifiche(EVENTO_LONTANO, "evento_promemoria_24h")).length, 0);
|
||||
assert.equal((await registro(EVENTO_LONTANO)).length, 0);
|
||||
});
|
||||
|
||||
await prova("il registro non si vede né si scrive da un client", async () => {
|
||||
const lettura = await rest("promemoria_eventi_generati?select=*", ANON);
|
||||
assert.ok(!lettura.ok, "anon non può leggere il registro");
|
||||
const inserimento = await rest("promemoria_eventi_generati", ANON, {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ giocatore_id: G4, evento_id: EVENTO, tipo: "evento_promemoria_3h" }),
|
||||
});
|
||||
assert.ok(!inserimento.ok, "anon non può scrivere nel registro");
|
||||
});
|
||||
|
||||
await prova("cancellare l'evento toglie anche il registro", async () => {
|
||||
const { data, ora } = { data: tra(2).data, ora: tra(2).ora };
|
||||
await scrivi("eventi_app", "POST", {
|
||||
id: EVENTO_CASCATA,
|
||||
tipo: "partita",
|
||||
titolo: `${PREFISSO} cascata`,
|
||||
data,
|
||||
ora,
|
||||
convocati: [G4],
|
||||
});
|
||||
await cron("evento_promemoria_24h");
|
||||
assert.equal((await registro(EVENTO_CASCATA)).length, 1);
|
||||
await scrivi(`eventi_app?id=eq.${EVENTO_CASCATA}`, "DELETE");
|
||||
assert.equal((await registro(EVENTO_CASCATA)).length, 0);
|
||||
});
|
||||
} finally {
|
||||
for (const id of [EVENTO, EVENTO_LONTANO, EVENTO_CASCATA]) {
|
||||
await rest(`eventi_app?id=eq.${id}`, SERVIZIO, { method: "DELETE" });
|
||||
}
|
||||
riepilogo("promemoria-eventi");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,434 @@
|
||||
/**
|
||||
* Push dei promemoria e sondaggio in-app (M24, DD-038): `bun test/integration/push-promemoria.test.ts`.
|
||||
*
|
||||
* Lato database: il trigger che accoda solo i promemoria a 24 e 3 ore, le funzioni RPC del worker
|
||||
* (`prendi_push_promemoria`, `esito_push_promemoria`), la RLS che tiene la coda lontana dai
|
||||
* client, e il nuovo tipo `sondaggio_cacche`. Il worker vero e la logica degli esiti sono coperti
|
||||
* da `unit/mailer-core.test.ts`; qui non parte nessuna push.
|
||||
*
|
||||
* Gira solo sullo stack locale (`npx supabase start`): usa lo slot `g4` della rosa seed e
|
||||
* iscrizioni push con endpoint `https://push.test-push-promemoria.example/…`, tolte alla fine.
|
||||
*/
|
||||
import assert from "node:assert/strict";
|
||||
import { statoLocale } from "../helpers/locale";
|
||||
import { prova, riepilogo, salta } from "../helpers/prova";
|
||||
|
||||
const locale = statoLocale();
|
||||
|
||||
if (!locale) {
|
||||
salta("push promemoria", "stack locale non attivo (npx supabase start)");
|
||||
riepilogo("push-promemoria");
|
||||
} else {
|
||||
const { url: URL_BASE, anon: ANON, servizio: SERVIZIO } = locale;
|
||||
console.log(`push promemoria su ${URL_BASE}`);
|
||||
|
||||
const PREFISSO = "test-push-promemoria";
|
||||
const G4 = "g4";
|
||||
const G5 = "g5";
|
||||
const ENDPOINT = (n: number) => `https://push.${PREFISSO}.example/${n}`;
|
||||
const EVENTI = ["a", "b", "c", "d"].map((x) => `${PREFISSO}-${x}`);
|
||||
let contatore = 0;
|
||||
const PASSWORD = "prova-push-promemoria-123";
|
||||
|
||||
const rest = (percorso: string, token: string, init?: RequestInit) =>
|
||||
fetch(`${URL_BASE}/rest/v1/${percorso}`, {
|
||||
...init,
|
||||
headers: {
|
||||
apikey: token === SERVIZIO ? SERVIZIO : ANON,
|
||||
Authorization: `Bearer ${token}`,
|
||||
"content-type": "application/json",
|
||||
...(init?.headers ?? {}),
|
||||
},
|
||||
});
|
||||
|
||||
async function leggi<T>(percorso: string, token = SERVIZIO): Promise<T[]> {
|
||||
const res = await rest(percorso, token);
|
||||
if (!res.ok) throw new Error(`select su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
return (await res.json()) as T[];
|
||||
}
|
||||
|
||||
async function scrivi(percorso: string, metodo: string, corpo?: unknown) {
|
||||
const res = await rest(percorso, SERVIZIO, {
|
||||
method: metodo,
|
||||
body: corpo === undefined ? null : JSON.stringify(corpo),
|
||||
});
|
||||
if (!res.ok) throw new Error(`${metodo} su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
|
||||
async function rpc<T = unknown>(nome: string, corpo: Record<string, unknown>, token = SERVIZIO) {
|
||||
const res = await fetch(`${URL_BASE}/rest/v1/rpc/${nome}`, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
apikey: token === SERVIZIO ? SERVIZIO : ANON,
|
||||
Authorization: `Bearer ${token}`,
|
||||
"content-type": "application/json",
|
||||
},
|
||||
body: JSON.stringify(corpo),
|
||||
});
|
||||
const testo = await res.text();
|
||||
return { ok: res.ok, dati: (testo ? JSON.parse(testo) : null) as T };
|
||||
}
|
||||
|
||||
async function creaUtente(email: string): Promise<{ id: string; token: string }> {
|
||||
const res = await fetch(`${URL_BASE}/auth/v1/admin/users`, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
apikey: SERVIZIO,
|
||||
Authorization: `Bearer ${SERVIZIO}`,
|
||||
"content-type": "application/json",
|
||||
},
|
||||
body: JSON.stringify({ email, password: PASSWORD, email_confirm: true }),
|
||||
});
|
||||
const corpo = (await res.json()) as { id?: string };
|
||||
if (!corpo.id) throw new Error(`creazione utente fallita: ${JSON.stringify(corpo)}`);
|
||||
const login = await fetch(`${URL_BASE}/auth/v1/token?grant_type=password`, {
|
||||
method: "POST",
|
||||
headers: { apikey: ANON, "content-type": "application/json" },
|
||||
body: JSON.stringify({ email, password: PASSWORD }),
|
||||
});
|
||||
const t = (await login.json()) as { access_token?: string };
|
||||
if (!t.access_token) throw new Error("accesso fallito");
|
||||
return { id: corpo.id, token: t.access_token };
|
||||
}
|
||||
|
||||
type Coda = {
|
||||
notifica_id: string;
|
||||
stato: string;
|
||||
tentativi: number;
|
||||
prossimo_tentativo: string;
|
||||
errore: string | null;
|
||||
inviata_il: string | null;
|
||||
};
|
||||
type Preso = {
|
||||
id_notifica: string;
|
||||
oggetto: string;
|
||||
testo: string;
|
||||
tentativi_fatti: number;
|
||||
iscrizioni: Array<{ endpoint: string; p256dh: string; auth: string }>;
|
||||
};
|
||||
|
||||
const evento = async (id: string, ore = 2) => {
|
||||
const quando = new Date(Date.now() + ore * 3_600_000);
|
||||
await scrivi("eventi_app", "POST", {
|
||||
id,
|
||||
tipo: "allenamento",
|
||||
titolo: `${PREFISSO} ${id}`,
|
||||
data: new Intl.DateTimeFormat("en-CA", { timeZone: "Europe/Rome" }).format(quando),
|
||||
ora: new Intl.DateTimeFormat("it-IT", {
|
||||
timeZone: "Europe/Rome",
|
||||
hour: "2-digit",
|
||||
minute: "2-digit",
|
||||
hour12: false,
|
||||
}).format(quando),
|
||||
convocati: [G4],
|
||||
});
|
||||
};
|
||||
|
||||
const creaNotifica = async (
|
||||
giocatoreId: string,
|
||||
tipo: string,
|
||||
eventoId: string | null = null,
|
||||
): Promise<string> => {
|
||||
contatore += 1;
|
||||
const res = await rest("notifiche_utente", SERVIZIO, {
|
||||
method: "POST",
|
||||
headers: { Prefer: "return=representation" },
|
||||
body: JSON.stringify({
|
||||
giocatore_id: giocatoreId,
|
||||
tipo,
|
||||
titolo: `${PREFISSO} titolo ${contatore}`,
|
||||
corpo: `${PREFISSO} corpo`,
|
||||
...(eventoId ? { evento_id: eventoId } : {}),
|
||||
}),
|
||||
});
|
||||
if (!res.ok) throw new Error(`insert notifica: ${res.status} ${await res.text()}`);
|
||||
return ((await res.json()) as { id: string }[])[0]!.id;
|
||||
};
|
||||
|
||||
/** Evento nuovo e un promemoria per g4: (giocatore, evento, tipo) è UNIQUE, ogni prova ha il suo. */
|
||||
const eventiCreati: string[] = [];
|
||||
const fresco = async (tipo = "evento_promemoria_24h"): Promise<string> => {
|
||||
contatore += 1;
|
||||
const id = `${PREFISSO}-x${contatore}`;
|
||||
await evento(id, 40);
|
||||
eventiCreati.push(id);
|
||||
return creaNotifica(G4, tipo, id);
|
||||
};
|
||||
|
||||
const coda = async (id: string): Promise<Coda | undefined> =>
|
||||
(await leggi<Coda>(`notifiche_push_coda?notifica_id=eq.${id}&select=*`))[0];
|
||||
const codaEmail = async (id: string) =>
|
||||
(await leggi<{ stato: string }>(`notifiche_email_coda?notifica_id=eq.${id}&select=stato`))[0];
|
||||
|
||||
const prendi = async (mie: string[], max = 100): Promise<Preso[]> => {
|
||||
const r = await rpc<Preso[]>("prendi_push_promemoria", { p_max: max });
|
||||
assert.ok(r.ok, "prendi_push_promemoria");
|
||||
return r.dati.filter((p) => mie.includes(p.id_notifica));
|
||||
};
|
||||
|
||||
const esito = async (
|
||||
id: string,
|
||||
tipo: string,
|
||||
errore: string | null = null,
|
||||
prossimo: string | null = null,
|
||||
) => {
|
||||
const r = await rpc("esito_push_promemoria", {
|
||||
p_id: id,
|
||||
p_esito: tipo,
|
||||
p_errore: errore,
|
||||
p_prossimo: prossimo,
|
||||
});
|
||||
assert.ok(r.ok, `esito_push_promemoria ${tipo}`);
|
||||
};
|
||||
|
||||
const iscrivi = (giocatoreId: string, n: number) =>
|
||||
scrivi("push_subscriptions", "POST", {
|
||||
giocatore_id: giocatoreId,
|
||||
endpoint: ENDPOINT(n),
|
||||
p256dh: `k${n}`,
|
||||
auth: `a${n}`,
|
||||
});
|
||||
|
||||
const idUtenti: string[] = [];
|
||||
try {
|
||||
const utente = await creaUtente(`${PREFISSO}-giocatore-${Date.now()}@example.test`);
|
||||
idUtenti.push(utente.id);
|
||||
for (const id of EVENTI) await evento(id);
|
||||
|
||||
// --- 1. Trigger ---------------------------------------------------------------------
|
||||
await prova("solo i promemoria a 24 e 3 ore finiscono nella coda push", async () => {
|
||||
const promemoria = [
|
||||
await creaNotifica(G4, "evento_promemoria_24h", EVENTI[0]),
|
||||
await creaNotifica(G4, "evento_promemoria_3h", EVENTI[0]),
|
||||
];
|
||||
const altre = [
|
||||
await creaNotifica(G4, "admin"),
|
||||
await creaNotifica(G4, "turno_palloni", EVENTI[0]),
|
||||
await creaNotifica(G4, "sollecita_presenze", EVENTI[0]),
|
||||
await creaNotifica(G4, "sondaggio_cacche", EVENTI[0]),
|
||||
];
|
||||
for (const id of promemoria) {
|
||||
const riga = await coda(id);
|
||||
assert.equal(riga?.stato, "in_coda");
|
||||
assert.equal(riga?.tentativi, 0);
|
||||
}
|
||||
for (const id of altre) {
|
||||
assert.equal(await coda(id), undefined, "la push di queste parte già dall'app");
|
||||
}
|
||||
});
|
||||
|
||||
await prova(
|
||||
"il sondaggio è un tipo valido, e la sua mail parte dal trigger di M22",
|
||||
async () => {
|
||||
const id = await creaNotifica(G4, "sondaggio_cacche", EVENTI[1]);
|
||||
assert.equal((await codaEmail(id))?.stato, "in_coda");
|
||||
assert.equal(await coda(id), undefined);
|
||||
},
|
||||
);
|
||||
|
||||
await prova("un tipo sconosciuto è ancora rifiutato dal vincolo", async () => {
|
||||
const res = await rest("notifiche_utente", SERVIZIO, {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ giocatore_id: G4, tipo: "boh", titolo: "x", corpo: "y" }),
|
||||
});
|
||||
assert.ok(!res.ok);
|
||||
});
|
||||
|
||||
// --- 2. prendi_push_promemoria ------------------------------------------------------
|
||||
await prova(
|
||||
"prendi restituisce testo e iscrizioni del giocatore e marca la riga in_invio",
|
||||
async () => {
|
||||
await iscrivi(G4, 1);
|
||||
await iscrivi(G4, 2);
|
||||
const id = await fresco("evento_promemoria_3h");
|
||||
const [p] = await prendi([id]);
|
||||
assert.ok(p, "la riga è stata presa");
|
||||
assert.match(p.oggetto, new RegExp(PREFISSO));
|
||||
assert.equal(p.tentativi_fatti, 0);
|
||||
assert.deepEqual(p.iscrizioni.map((i) => i.endpoint).sort(), [ENDPOINT(1), ENDPOINT(2)]);
|
||||
assert.equal(p.iscrizioni[0]?.p256dh.startsWith("k"), true);
|
||||
assert.equal((await coda(id))?.stato, "in_invio");
|
||||
},
|
||||
);
|
||||
|
||||
await prova("una seconda chiamata non restituisce di nuovo la stessa riga", async () => {
|
||||
const id = await fresco();
|
||||
assert.equal((await prendi([id])).length, 1);
|
||||
assert.equal((await prendi([id])).length, 0);
|
||||
});
|
||||
|
||||
await prova("due chiamate concorrenti si dividono le righe senza doppioni", async () => {
|
||||
const ids = await Promise.all(Array.from({ length: 5 }, () => fresco()));
|
||||
const [a, b] = await Promise.all([prendi(ids, 3), prendi(ids, 3)]);
|
||||
const tutti = [...a, ...b].map((p) => p.id_notifica);
|
||||
assert.equal(tutti.length, new Set(tutti).size, "nessuna riga presa due volte");
|
||||
const resto = (await prendi(ids)).map((p) => p.id_notifica);
|
||||
assert.deepEqual([...tutti, ...resto].sort(), [...ids].sort());
|
||||
});
|
||||
|
||||
await prova("giocatore senza dispositivi: 'saltata', mai presa", async () => {
|
||||
const id = await creaNotifica(G5, "evento_promemoria_24h", EVENTI[0]);
|
||||
assert.equal((await prendi([id])).length, 0);
|
||||
const riga = await coda(id);
|
||||
assert.equal(riga?.stato, "saltata");
|
||||
assert.equal(riga?.errore, null);
|
||||
});
|
||||
|
||||
await prova("promemoria creato da più di 3 ore: 'saltata', la push non serve più", async () => {
|
||||
const id = await fresco("evento_promemoria_3h");
|
||||
const vecchia = new Date(Date.now() - 4 * 3_600_000).toISOString();
|
||||
await scrivi(`notifiche_utente?id=eq.${id}`, "PATCH", { creato_il: vecchia });
|
||||
assert.equal((await prendi([id])).length, 0);
|
||||
assert.equal((await coda(id))?.stato, "saltata");
|
||||
});
|
||||
|
||||
await prova(
|
||||
"la riga rimasta in invio per un worker morto viene ripresa dopo 10 minuti",
|
||||
async () => {
|
||||
const id = await fresco();
|
||||
assert.equal((await prendi([id])).length, 1);
|
||||
assert.equal((await prendi([id])).length, 0, "ancora in invio");
|
||||
await scrivi(`notifiche_push_coda?notifica_id=eq.${id}`, "PATCH", {
|
||||
aggiornata_il: new Date(Date.now() - 11 * 60_000).toISOString(),
|
||||
});
|
||||
assert.equal((await prendi([id])).length, 1, "recuperata");
|
||||
},
|
||||
);
|
||||
|
||||
// --- 3. esito_push_promemoria -------------------------------------------------------
|
||||
const nuovaInvio = async () => {
|
||||
const id = await fresco();
|
||||
await prendi([id]);
|
||||
return id;
|
||||
};
|
||||
|
||||
await prova("'inviata': stato e orario, errore azzerato", async () => {
|
||||
const id = await nuovaInvio();
|
||||
await esito(id, "inviata");
|
||||
const riga = await coda(id);
|
||||
assert.equal(riga?.stato, "inviata");
|
||||
assert.ok(riga?.inviata_il);
|
||||
assert.equal(riga?.errore, null);
|
||||
});
|
||||
|
||||
await prova(
|
||||
"'riprova': conta un tentativo e non viene ripresa prima dell'ora fissata",
|
||||
async () => {
|
||||
const id = await nuovaInvio();
|
||||
await esito(id, "riprova", "503", new Date(Date.now() + 3_600_000).toISOString());
|
||||
const riga = await coda(id);
|
||||
assert.equal(riga?.stato, "in_coda");
|
||||
assert.equal(riga?.tentativi, 1);
|
||||
assert.equal(riga?.errore, "503");
|
||||
assert.equal((await prendi([id])).length, 0);
|
||||
await scrivi(`notifiche_push_coda?notifica_id=eq.${id}`, "PATCH", {
|
||||
prossimo_tentativo: new Date(Date.now() - 1000).toISOString(),
|
||||
});
|
||||
const [p] = await prendi([id]);
|
||||
assert.equal(p?.tentativi_fatti, 1);
|
||||
},
|
||||
);
|
||||
|
||||
await prova("'fallita' e 'saltata' sono definitive", async () => {
|
||||
const a = await nuovaInvio();
|
||||
await esito(a, "fallita", "403");
|
||||
assert.equal((await coda(a))?.stato, "fallita");
|
||||
assert.equal((await coda(a))?.tentativi, 1);
|
||||
const b = await nuovaInvio();
|
||||
await esito(b, "saltata", "410");
|
||||
assert.equal((await coda(b))?.stato, "saltata");
|
||||
assert.equal((await prendi([a, b])).length, 0);
|
||||
});
|
||||
|
||||
await prova(
|
||||
"un esito su una riga non 'in_invio' non cambia nulla, uno sconosciuto è rifiutato",
|
||||
async () => {
|
||||
const id = await nuovaInvio();
|
||||
await esito(id, "inviata");
|
||||
await esito(id, "fallita", "x");
|
||||
assert.equal((await coda(id))?.stato, "inviata", "l'esito già deciso non si sovrascrive");
|
||||
const r = await rpc("esito_push_promemoria", { p_id: id, p_esito: "boh" });
|
||||
assert.ok(!r.ok);
|
||||
},
|
||||
);
|
||||
|
||||
await prova("cancellare la notifica toglie anche la riga della coda push", async () => {
|
||||
const id = await fresco("evento_promemoria_3h");
|
||||
assert.ok(await coda(id));
|
||||
await scrivi(`notifiche_utente?id=eq.${id}`, "DELETE");
|
||||
assert.equal(await coda(id), undefined);
|
||||
});
|
||||
|
||||
await prova(
|
||||
"il job dei promemoria accoda la push una volta sola, anche se cancelli la notifica",
|
||||
async () => {
|
||||
await scrivi(`eventi_app?id=eq.${EVENTI[2]}`, "PATCH", { convocati: [G4] });
|
||||
const args = { p_tipo: "evento_promemoria_24h", p_finestra: "24 hours" };
|
||||
await rpc("genera_promemoria_eventi", args);
|
||||
const [n] = await leggi<{ id: string }>(
|
||||
`notifiche_utente?evento_id=eq.${EVENTI[2]}&tipo=eq.evento_promemoria_24h&select=id`,
|
||||
);
|
||||
assert.ok(n, "il job ha creato il promemoria");
|
||||
assert.equal((await coda(n.id))?.stato, "in_coda");
|
||||
|
||||
await scrivi(`notifiche_utente?id=eq.${n.id}`, "DELETE");
|
||||
assert.equal(await coda(n.id), undefined, "la coda sparisce con la notifica");
|
||||
await rpc("genera_promemoria_eventi", args);
|
||||
const dopo = await leggi<{ id: string }>(
|
||||
`notifiche_utente?evento_id=eq.${EVENTI[2]}&tipo=eq.evento_promemoria_24h&select=id`,
|
||||
);
|
||||
assert.equal(
|
||||
dopo.length,
|
||||
0,
|
||||
"M23: il promemoria eliminato non torna, quindi nessuna nuova push",
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
// --- 4. Permessi --------------------------------------------------------------------
|
||||
await prova("un utente autenticato non vede né scrive la coda push", async () => {
|
||||
const id = await nuovaInvio();
|
||||
const lettura = await rest("notifiche_push_coda?select=*", utente.token);
|
||||
const righe = lettura.ok ? ((await lettura.json()) as unknown[]) : [];
|
||||
assert.equal(righe.length, 0);
|
||||
const scrittura = await rest(`notifiche_push_coda?notifica_id=eq.${id}`, utente.token, {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify({ stato: "in_coda" }),
|
||||
});
|
||||
assert.ok(!scrittura.ok || (await scrittura.text()) === "");
|
||||
assert.equal((await coda(id))?.stato, "in_invio");
|
||||
const anon = await rest("notifiche_push_coda?select=*", ANON);
|
||||
assert.ok(!anon.ok, "anon non può leggere la coda");
|
||||
});
|
||||
|
||||
await prova("le funzioni push del worker sono chiamabili solo dalla service role", async () => {
|
||||
const id = await nuovaInvio();
|
||||
for (const token of [utente.token, ANON]) {
|
||||
const a = await rpc("prendi_push_promemoria", { p_max: 1 }, token);
|
||||
assert.ok(!a.ok, "prendi_push_promemoria");
|
||||
const b = await rpc("esito_push_promemoria", { p_id: id, p_esito: "fallita" }, token);
|
||||
assert.ok(!b.ok, "esito_push_promemoria");
|
||||
}
|
||||
assert.equal((await coda(id))?.stato, "in_invio");
|
||||
});
|
||||
} finally {
|
||||
await rest(
|
||||
`push_subscriptions?endpoint=like.${encodeURIComponent(`https://push.${PREFISSO}.example/*`)}`,
|
||||
SERVIZIO,
|
||||
{
|
||||
method: "DELETE",
|
||||
},
|
||||
);
|
||||
await rest(`notifiche_utente?titolo=like.${PREFISSO}*`, SERVIZIO, { method: "DELETE" });
|
||||
for (const id of [...EVENTI, ...eventiCreati]) {
|
||||
await rest(`eventi_app?id=eq.${id}`, SERVIZIO, { method: "DELETE" });
|
||||
}
|
||||
for (const id of idUtenti) {
|
||||
await fetch(`${URL_BASE}/auth/v1/admin/users/${id}`, {
|
||||
method: "DELETE",
|
||||
headers: { apikey: SERVIZIO, Authorization: `Bearer ${SERVIZIO}` },
|
||||
});
|
||||
}
|
||||
riepilogo("push-promemoria");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
/**
|
||||
* Sondaggio pre-partita in-app ed email (M24, DD-038): `bun test/integration/sondaggio-notifiche.test.ts`.
|
||||
*
|
||||
* La route `apri-sondaggio` mandava solo la push. Ora scrive anche `notifiche_utente` (tipo
|
||||
* `sondaggio_cacche`) per i giocatori attivi, allenatori esclusi: compare nel centro notifiche e
|
||||
* la mail parte dal trigger di M22. Qui si verifica quella scrittura chiamando la route vera.
|
||||
*
|
||||
* Gira solo sullo stack locale (`npx supabase start`) e avvia il server di sviluppo puntato al
|
||||
* database locale (o usa quello indicato da `BASE_URL`). Usa gli slot `g5` (reso non attivo) e
|
||||
* `g6` (reso allenatore) della rosa seed, ripristinati alla fine.
|
||||
*/
|
||||
import assert from "node:assert/strict";
|
||||
import { statoLocale } from "../helpers/locale";
|
||||
import { avviaServer } from "../helpers/server";
|
||||
import { prova, riepilogo, salta } from "../helpers/prova";
|
||||
|
||||
const locale = statoLocale();
|
||||
|
||||
if (!locale) {
|
||||
salta("sondaggio in-app", "stack locale non attivo (npx supabase start)");
|
||||
riepilogo("sondaggio-notifiche");
|
||||
} else {
|
||||
const { url: URL_BASE, anon: ANON, servizio: SERVIZIO } = locale;
|
||||
console.log(`sondaggio in-app su ${URL_BASE}`);
|
||||
|
||||
// Il server di sviluppo eredita queste: senza, le route punterebbero al progetto cloud.
|
||||
process.env["SUPABASE_URL"] = URL_BASE;
|
||||
process.env["SUPABASE_PUBLISHABLE_KEY"] = ANON;
|
||||
process.env["SUPABASE_SERVICE_ROLE_KEY"] = SERVIZIO;
|
||||
|
||||
const PREFISSO = "test-sondaggio-notifiche";
|
||||
const PARTITA = `${PREFISSO}-partita`;
|
||||
const INATTIVO = "g5";
|
||||
const ALLENATORE = "g6";
|
||||
const PASSWORD = "prova-sondaggio-notifiche-123";
|
||||
|
||||
const rest = (percorso: string, token: string, init?: RequestInit) =>
|
||||
fetch(`${URL_BASE}/rest/v1/${percorso}`, {
|
||||
...init,
|
||||
headers: {
|
||||
apikey: token === SERVIZIO ? SERVIZIO : ANON,
|
||||
Authorization: `Bearer ${token}`,
|
||||
"content-type": "application/json",
|
||||
...(init?.headers ?? {}),
|
||||
},
|
||||
});
|
||||
|
||||
async function leggi<T>(percorso: string): Promise<T[]> {
|
||||
const res = await rest(percorso, SERVIZIO);
|
||||
if (!res.ok) throw new Error(`select su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
return (await res.json()) as T[];
|
||||
}
|
||||
|
||||
async function scrivi(percorso: string, token: string, metodo: string, corpo?: unknown) {
|
||||
const res = await rest(percorso, token, {
|
||||
method: metodo,
|
||||
body: corpo === undefined ? null : JSON.stringify(corpo),
|
||||
});
|
||||
if (!res.ok) throw new Error(`${metodo} su ${percorso}: ${res.status} ${await res.text()}`);
|
||||
}
|
||||
|
||||
async function creaUtente(email: string): Promise<{ id: string; token: string }> {
|
||||
const res = await fetch(`${URL_BASE}/auth/v1/admin/users`, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
apikey: SERVIZIO,
|
||||
Authorization: `Bearer ${SERVIZIO}`,
|
||||
"content-type": "application/json",
|
||||
},
|
||||
body: JSON.stringify({ email, password: PASSWORD, email_confirm: true }),
|
||||
});
|
||||
const corpo = (await res.json()) as { id?: string };
|
||||
if (!corpo.id) throw new Error(`creazione utente fallita: ${JSON.stringify(corpo)}`);
|
||||
const login = await fetch(`${URL_BASE}/auth/v1/token?grant_type=password`, {
|
||||
method: "POST",
|
||||
headers: { apikey: ANON, "content-type": "application/json" },
|
||||
body: JSON.stringify({ email, password: PASSWORD }),
|
||||
});
|
||||
const t = (await login.json()) as { access_token?: string };
|
||||
if (!t.access_token) throw new Error("accesso fallito");
|
||||
return { id: corpo.id, token: t.access_token };
|
||||
}
|
||||
|
||||
type Notifica = {
|
||||
id: string;
|
||||
giocatore_id: string;
|
||||
letta: boolean;
|
||||
titolo: string;
|
||||
creato_il: string;
|
||||
};
|
||||
const notifiche = () =>
|
||||
leggi<Notifica>(
|
||||
`notifiche_utente?evento_id=eq.${PARTITA}&tipo=eq.sondaggio_cacche&select=id,giocatore_id,letta,titolo,creato_il&order=giocatore_id`,
|
||||
);
|
||||
|
||||
const idUtenti: string[] = [];
|
||||
let server: { baseUrl: string; stop: () => void } | null = null;
|
||||
let tokenAdmin = "";
|
||||
const originali = new Map<string, { attivo: boolean; tipo: string }>();
|
||||
|
||||
try {
|
||||
const admin = await creaUtente(`${PREFISSO}-admin-${Date.now()}@example.test`);
|
||||
const giocatore = await creaUtente(`${PREFISSO}-giocatore-${Date.now()}@example.test`);
|
||||
idUtenti.push(admin.id, giocatore.id);
|
||||
await scrivi("user_roles", SERVIZIO, "POST", { user_id: admin.id, role: "admin" });
|
||||
tokenAdmin = admin.token;
|
||||
|
||||
for (const id of [INATTIVO, ALLENATORE]) {
|
||||
const [riga] = await leggi<{ attivo: boolean; tipo: string }>(
|
||||
`giocatori_squadra?id=eq.${id}&select=attivo,tipo`,
|
||||
);
|
||||
originali.set(id, riga ?? { attivo: true, tipo: "giocatore" });
|
||||
}
|
||||
// Il trigger di `giocatori_squadra` rifiuta la service key: serve il JWT dell'admin.
|
||||
await scrivi(`giocatori_squadra?id=eq.${INATTIVO}`, tokenAdmin, "PATCH", { attivo: false });
|
||||
await scrivi(`giocatori_squadra?id=eq.${ALLENATORE}`, tokenAdmin, "PATCH", {
|
||||
tipo: "allenatore",
|
||||
});
|
||||
await scrivi("eventi_app", SERVIZIO, "POST", {
|
||||
id: PARTITA,
|
||||
tipo: "partita",
|
||||
titolo: `${PREFISSO} partita`,
|
||||
data: "2030-01-01",
|
||||
ora: "21:00",
|
||||
convocati: [],
|
||||
});
|
||||
|
||||
const attesi = (
|
||||
await leggi<{ id: string }>("giocatori_squadra?attivo=eq.true&tipo=eq.giocatore&select=id")
|
||||
)
|
||||
.map((g) => g.id)
|
||||
.sort();
|
||||
assert.ok(attesi.length > 3, "la rosa seed ha più giocatori attivi");
|
||||
assert.ok(!attesi.includes(INATTIVO) && !attesi.includes(ALLENATORE));
|
||||
|
||||
server = await avviaServer();
|
||||
console.log(`route apri-sondaggio su ${server.baseUrl}`);
|
||||
const chiama = (token: string) =>
|
||||
fetch(`${server!.baseUrl}/api/public/apri-sondaggio`, {
|
||||
method: "POST",
|
||||
headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
|
||||
body: JSON.stringify({ eventoId: PARTITA }),
|
||||
});
|
||||
|
||||
await prova("chi non è admin non può aprire il sondaggio e non scrive nulla", async () => {
|
||||
const res = await chiama(giocatore.token);
|
||||
assert.ok(!res.ok, `stato ${res.status}`);
|
||||
assert.equal((await notifiche()).length, 0);
|
||||
});
|
||||
|
||||
await prova("l'admin apre il sondaggio: una notifica per ogni giocatore attivo", async () => {
|
||||
const res = await chiama(tokenAdmin);
|
||||
assert.equal(res.status, 200);
|
||||
const righe = await notifiche();
|
||||
assert.deepEqual(righe.map((r) => r.giocatore_id).sort(), attesi);
|
||||
assert.ok(righe.every((r) => r.titolo === "💩 Sondaggio pre-partita aperto"));
|
||||
assert.ok(righe.every((r) => !r.letta));
|
||||
});
|
||||
|
||||
await prova("l'allenatore e chi non è attivo non ricevono l'avviso in-app", async () => {
|
||||
const righe = await notifiche();
|
||||
assert.ok(!righe.some((r) => r.giocatore_id === ALLENATORE));
|
||||
assert.ok(!righe.some((r) => r.giocatore_id === INATTIVO));
|
||||
});
|
||||
|
||||
await prova(
|
||||
"l'avviso arriva anche a chi non ha nessun dispositivo iscritto alla push",
|
||||
async () => {
|
||||
const iscritti = await leggi<{ giocatore_id: string }>(
|
||||
"push_subscriptions?select=giocatore_id",
|
||||
);
|
||||
const conPush = new Set(iscritti.map((i) => i.giocatore_id));
|
||||
const senza = attesi.filter((id) => !conPush.has(id));
|
||||
assert.ok(senza.length > 0, "nel database di prova nessuno ha la push");
|
||||
const righe = await notifiche();
|
||||
for (const id of senza)
|
||||
assert.ok(
|
||||
righe.some((r) => r.giocatore_id === id),
|
||||
id,
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
await prova(
|
||||
"ogni notifica del sondaggio ha la sua mail in coda e nessuna riga push",
|
||||
async () => {
|
||||
const righe = await notifiche();
|
||||
const ids = righe.map((r) => r.id).join(",");
|
||||
const email = await leggi<{ notifica_id: string }>(
|
||||
`notifiche_email_coda?notifica_id=in.(${ids})&select=notifica_id`,
|
||||
);
|
||||
assert.equal(email.length, righe.length, "una mail per notifica");
|
||||
const push = await leggi<{ notifica_id: string }>(
|
||||
`notifiche_push_coda?notifica_id=in.(${ids})&select=notifica_id`,
|
||||
);
|
||||
assert.equal(push.length, 0, "la push del sondaggio parte già dalla route");
|
||||
},
|
||||
);
|
||||
|
||||
await prova(
|
||||
"ripremere il pulsante aggiorna le notifiche, riporta a non letta e rimanda la mail",
|
||||
async () => {
|
||||
const prima = await notifiche();
|
||||
const [scelta] = prima;
|
||||
assert.ok(scelta);
|
||||
await scrivi(`notifiche_utente?id=eq.${scelta.id}`, SERVIZIO, "PATCH", { letta: true });
|
||||
await scrivi(`notifiche_email_coda?notifica_id=eq.${scelta.id}`, SERVIZIO, "PATCH", {
|
||||
stato: "inviata",
|
||||
});
|
||||
|
||||
const res = await chiama(tokenAdmin);
|
||||
assert.equal(res.status, 200);
|
||||
|
||||
const dopo = await notifiche();
|
||||
assert.equal(
|
||||
dopo.length,
|
||||
prima.length,
|
||||
"nessun doppione: upsert su giocatore, evento e tipo",
|
||||
);
|
||||
const aggiornata = dopo.find((r) => r.id === scelta.id);
|
||||
assert.equal(aggiornata?.letta, false);
|
||||
assert.ok(aggiornata!.creato_il > scelta.creato_il, "creato_il rinnovato");
|
||||
const [coda] = await leggi<{ stato: string }>(
|
||||
`notifiche_email_coda?notifica_id=eq.${scelta.id}&select=stato`,
|
||||
);
|
||||
assert.equal(coda?.stato, "in_coda", "la mail riparte");
|
||||
},
|
||||
);
|
||||
} finally {
|
||||
server?.stop();
|
||||
await rest(`notifiche_utente?evento_id=eq.${PARTITA}`, SERVIZIO, { method: "DELETE" });
|
||||
await rest(`eventi_app?id=eq.${PARTITA}`, SERVIZIO, { method: "DELETE" });
|
||||
if (tokenAdmin) {
|
||||
for (const [id, valori] of originali) {
|
||||
await rest(`giocatori_squadra?id=eq.${id}`, tokenAdmin, {
|
||||
method: "PATCH",
|
||||
body: JSON.stringify(valori),
|
||||
});
|
||||
}
|
||||
}
|
||||
for (const id of idUtenti) {
|
||||
await rest(`user_roles?user_id=eq.${id}`, SERVIZIO, { method: "DELETE" });
|
||||
await fetch(`${URL_BASE}/auth/v1/admin/users/${id}`, {
|
||||
method: "DELETE",
|
||||
headers: { apikey: SERVIZIO, Authorization: `Bearer ${SERVIZIO}` },
|
||||
});
|
||||
}
|
||||
riepilogo("sondaggio-notifiche");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user