feat(resenas): reseñas anónimas múltiples por local (issue #6)
deploy-branch / deploy (push) Successful in 2m56s
deploy-branch / teardown (push) Skipped
tests / Unitarias + componente + build (push) Failing after 3m14s
tests / Integración (Nominatim real, opt-in) (push) Skipped
tests / Unitarias + componente + build (pull_request) Failing after 3m6s
tests / Integración (Nominatim real, opt-in) (pull_request) Skipped

Una reseña por dispositivo (UNIQUE localId+deviceId, upsert editable),
puntuación 1-5 + comentario ≤500, publicación directa con filtro de
palabras server-side y reportes con resenaId; borrado admin desde el
panel. locales.puntuacion pasa a ser la media (ROUND) recalculada en
cada escritura; GET /api/locales añade totalResenas.

Identidad v1 anónima estilo 4chan: deviceId en localStorage, huella
corta por local (sha256(deviceId:localId)), nunca se expone el deviceId.
Anti-boicot base: rate-limit por IP (10/h, configurable con
LOCALESP_RESENAS_RATELIMIT_MAX, 429+Retry-After). UI: sección plegable
"Reseñas (N) · ★media" en la tarjeta con formulario inline.

Suite: 132/132 (+18 tests: rutas, rate-limit y componente).
This commit is contained in:
2026-10-11 23:01:25 +02:00
parent dd6febf8b0
commit 38ea2830fb
14 changed files with 893 additions and 34 deletions
+4
View File
@@ -18,3 +18,7 @@ LOCALESP_ADMIN_PREFIX=
# Opcional: ruta de la base de datos SQLite (por defecto localesp.db del
# repo; en pruebas se usa ":memory:").
# LOCALESP_DB=
# Opcional: máximo de escrituras de reseñas (crear/editar/borrar) por IP y
# hora, como defensa base anti-boicot (por defecto 10; 429 al exceder).
# LOCALESP_RESENAS_RATELIMIT_MAX=10
+32 -1
View File
@@ -21,12 +21,43 @@ seguridad real).
| `$ADMIN_PREFIX/locales/:id` | DELETE |
| `$ADMIN_PREFIX/reportes` | GET |
| `$ADMIN_PREFIX/reportes/:id/descartar` | POST |
| `$ADMIN_PREFIX/resenas` | GET |
| `$ADMIN_PREFIX/resenas/:id` | DELETE |
Siguen siendo públicas (las usa la web): `GET /api/locales`,
`POST /api/propuestas`, `POST /api/check-duplicado`,
`POST /api/locales/:id/confirmar`, `POST /api/locales/:id/reportar` y
`POST /api/locales/:id/confirmar`, `POST /api/locales/:id/reportar`,
`GET/POST /api/locales/:id/resenas`, `DELETE /api/locales/:id/resenas` y
`GET/POST /api/config/filtro_palabras`.
## Reseñas por local (issue #6)
Cada local publicado tiene **reseñas anónimas múltiples**: una por
dispositivo, editable y borrable por su autor; `locales.puntuacion` es la
**media** (redondeo de SQLite) de las reseñas vigentes y se recalcula al
crear/editar/borrar.
- **Identidad anónima:** `deviceId` aleatorio persistido en `localStorage`
(sin cuentas ni datos personales, "estilo 4chan"). Cada reseña se muestra
como `Anónimo #xxx` con una huella corta derivada de
`sha256(deviceId:localId)`: estable dentro del local, no reversible y no
rastreable entre locales. El deviceId completo nunca sale del servidor.
- **Contrato público:** `GET /api/locales/:id/resenas` (admite `?deviceId=`
para marcar la propia), `POST /api/locales/:id/resenas`
(`{ deviceId, puntuacion 1–5, comentario ≤500 }`, upsert: crea 201 o edita
200) y `DELETE /api/locales/:id/resenas?deviceId=…` (borra la propia).
`GET /api/locales` incluye `totalResenas` por local.
- **Moderación:** publicación directa; el filtro de palabras se aplica al
comentario server-side. Una reseña concreta se reporta con
`POST /api/locales/:id/reportar` añadiendo `resenaId`; el admin la borra
desde el panel (pestaña Reportes → «Borrar reseña», también vía
`DELETE $ADMIN_PREFIX/resenas/:id`).
- **Anti-abuso:** rate-limit por IP en las escrituras de reseñas (por defecto
10/hora, configurable con `LOCALESP_RESENAS_RATELIMIT_MAX`; responde 429
con `Retry-After`) más la unicidad por dispositivo. El DDoS volumétrico se
mitiga en el borde (proxy/CDN), no en la app. Las cuentas de usuario
quedarán como trabajo futuro (migración deviceId→userId prevista).
### Configuración
`LOCALESP_ADMIN_PREFIX` es **obligatoria, sin valor por defecto y la única
+29 -19
View File
@@ -6,37 +6,47 @@
> `locales.puntuacion`, publicación directa + reportes, rate-limit por IP.
> Detalles de esquema y endpoints: design.md.
> **Estado:** implementado y verificado. `./node_modules/.bin/vitest run` →
> **132/132 en verde** (19 ficheros), con 18 tests nuevos: 9 de rutas en
> `test-resenas.spec.js` (upsert, contrato 400/404, filtro, media, reportes
> y moderación admin), 1 de rate-limit 429 en `test-resenas-ratelimit.spec.js`
> y 6 de componente en `ResenasLocal.spec.jsx` (mockeando api.js). Extra no
> previsto en las tareas y añadido para cubrir el escenario del spec
> «borrado admin desde el panel»: botón «🗑 Borrar reseña» en la pestaña
> Reportes del AdminPanel (borra la reseña y descarta el aviso).
## 1. BD (server/db.js)
- [ ] 1.1 Crear tabla `resenas` (id, localId, deviceId, puntuacion 1–5 CHECK, comentario, fecha, fechaEdicion, UNIQUE(localId, deviceId))
- [ ] 1.2 `ensureColumn("reportes", "resenaId", "TEXT")` para reportar reseñas concretas
- [x] 1.1 Crear tabla `resenas` (id, localId, deviceId, puntuacion 1–5 CHECK, comentario, fecha, fechaEdicion, UNIQUE(localId, deviceId))
- [x] 1.2 `ensureColumn("reportes", "resenaId", "TEXT")` para reportar reseñas concretas
## 2. Servidor (server/index.js)
- [ ] 2.1 Helper `recalcularMedia(localId)`: `UPDATE locales SET puntuacion = ROUND(AVG(resenas.puntuacion))` (0 si vacío)
- [ ] 2.2 `GET /api/locales/:id/resenas` → 200 lista pública sin deviceId completo (huella corta por reseña: 3 hex de sha256(deviceId+localId))
- [ ] 2.3 `POST /api/locales/:id/resenas` upsert: valida puntuacion 1–5 y comentario ≤500; 404 si el local no existe; filtro de palabras en el comentario; crea (201) o edita la propia (200, fechaEdicion); recalcula media
- [ ] 2.4 `DELETE /api/locales/:id/resenas` con deviceId → borra la propia (200) y recalcula; 404 si no tiene reseña
- [ ] 2.5 Rate-limit por IP en POST/DELETE de reseñas (en memoria o express-rate-limit; 429 al exceder)
- [ ] 2.6 Extender `POST /api/locales/:id/reportar` para aceptar `resenaId` opcional (reporte de reseña)
- [ ] 2.7 Admin bajo prefijo: `GET $PREFIX/resenas` (lista con datos completos) y `DELETE $PREFIX/resenas/:id` (borrado de moderación + recálculo)
- [x] 2.1 Helper `recalcularMedia(localId)`: `UPDATE locales SET puntuacion = ROUND(AVG(resenas.puntuacion))` (0 si vacío)
- [x] 2.2 `GET /api/locales/:id/resenas` → 200 lista pública sin deviceId completo (huella corta por reseña: 3 hex de sha256(deviceId+localId)); `?deviceId=` marca `esPropia`
- [x] 2.3 `POST /api/locales/:id/resenas` upsert: valida puntuacion 1–5 y comentario ≤500; 404 si el local no existe; filtro de palabras en el comentario; crea (201) o edita la propia (200, fechaEdicion); recalcula media
- [x] 2.4 `DELETE /api/locales/:id/resenas` con deviceId → borra la propia (200) y recalcula; 404 si no tiene reseña
- [x] 2.5 Rate-limit por IP en POST/DELETE de reseñas (mapa en memoria, ventana 1h, `LOCALESP_RESENAS_RATELIMIT_MAX` configurable, 429 + Retry-After)
- [x] 2.6 Extender `POST /api/locales/:id/reportar` para aceptar `resenaId` opcional (404 si la reseña no existe en ese local)
- [x] 2.7 Admin bajo prefijo: `GET $PREFIX/resenas` (lista con localNombre) y `DELETE $PREFIX/resenas/:id` (borrado de moderación + recálculo)
- [x] (extra) `GET /api/locales` incluye `totalResenas` por local (para plegar "Reseñas (N)" sin expandir)
## 3. Frontend
- [ ] 3.1 Util `deviceId` persistente en localStorage (UUID v4, creación perezosa) en `src/utils/`
- [ ] 3.2 Cliente API de reseñas en `src/api.js` (listar, enviar upsert, borrar propia) con el deviceId
- [ ] 3.3 `StarRating` interactivo (modo edición: click 1–5) manteniendo el readOnly actual
- [ ] 3.4 Componente `ResenasLocal` desplegable: cabecera "Reseñas (N) · ★media", carga perezosa al expandir, lista (huella, estrellas, comentario, fecha, marca "editada") y formulario inline (estrellas + textarea 500)
- [ ] 3.5 Integrar en `LocalCard.jsx`: precargar el formulario con la reseña propia y ofrecer Actualizar/Borrar; reportar reseña ajena desde la lista
- [ ] 3.6 Verificar que popup del mapa, orden "★ Mejor" y media global siguen correctos con la puntuación agregada (sin cambios de código previstos)
- [x] 3.1 Util `deviceId` persistente en localStorage (`src/utils/dispositivo.js`; UUID v4 con fallback, tolerante a almacenamiento no disponible)
- [x] 3.2 Cliente API de reseñas en `src/api.js` (listar con deviceId, enviar upsert, borrar propia, `obtenerResenas`/`borrarResenaAdmin` de moderación) + re-exports en `firebase.js`; `reportarLocal` acepta `resenaId`
- [x] 3.3 `StarRating` interactivo: ya existía (`onChange` con role="radio"); usado tal cual en el formulario
- [x] 3.4 Componente `ResenasLocal` desplegable: cabecera "★media · Reseñas (N)", carga perezosa al expandir, lista (huella, estrellas, comentario, fecha, marca "editada", ⚑ reportar ajenas) y formulario inline (estrellas + textarea 500 + Publicar/Actualizar + Borrar mi reseña); errores (filtro/429) como alerta
- [x] 3.5 Integrar en `LocalCard.jsx` (sustituye la fila de estrellas read-only; la media y el total se actualizan en local tras escribir) + botón «🗑 Borrar reseña» en el AdminPanel (pestaña Reportes, para reportes con resenaId)
- [x] 3.6 Popup del mapa, orden "★ Mejor" y media global consumen `local.puntuacion` (ahora media agregada): sin cambios, verificado por revisión de código (los tres leen el mismo campo)
## 4. Tests
- [ ] 4.1 `tests/unit/test-routes.spec.js` (o fichero nuevo `test-resenas.spec.js`): upsert (una por dispositivo), 400 sin puntuacion/fuera de rango/comentario >500, 404 local inexistente, filtro de palabras, recálculo de media al crear/editar/borrar (incl. borrado admin), reporte con resenaId, rate-limit 429
- [ ] 4.2 Tests de componente: `ResenasLocal` plegado/expandido, formulario con estrellas, precarga de la propia, envío y borrado
- [ ] 4.3 Suite completa en verde: `./node_modules/.bin/vitest run`
- [x] 4.1 `tests/unit/test-resenas.spec.js`: upsert (una por dispositivo), 400 sin puntuacion/fuera de rango/comentario >500/deviceId inválido, 404 local inexistente, filtro de palabras server-side, recálculo de media al crear/editar/borrar (ROUND: 4.5→5, 2.5→3), reporte con resenaId, listado/borrado admin con recálculo, `totalResenas` en `/api/locales`
- [x] 4.2 `tests/component/ResenasLocal.spec.jsx`: plegado sin cargar, expansión con carga perezosa (huella, estrellas, deviceId en localStorage), envío con estrellas+comentario, precarga de la propia (Actualizar/Borrar), reporte de ajena con resenaId, aviso de error del servidor
- [x] 4.3 Suite completa en verde: `./node_modules/.bin/vitest run` → **132/132** (+`tests/unit/test-resenas-ratelimit.spec.js`: 429 con Retry-After, DELETE limitado, lectura disponible)
## 5. Cierre
- [ ] 5.1 README: documentar reseñas (contrato de la API pública, moderación, anonimato y su huella, rate-limit)
- [x] 5.1 README: sección «Reseñas por local (issue #6)» (contrato público, moderación, anonimato y huella, rate-limit) + rutas admin nuevas en la tabla + `.env.example` con `LOCALESP_RESENAS_RATELIMIT_MAX`
- [ ] 5.2 Referenciar la issue #6 en el commit de cierre y verificar despliegue en prototipo-yb01.localesp.es
+16
View File
@@ -48,6 +48,7 @@ db.exec(`
CREATE TABLE IF NOT EXISTS reportes (
id TEXT PRIMARY KEY,
localId TEXT NOT NULL,
resenaId TEXT,
motivo TEXT,
comentario TEXT,
fecha TEXT DEFAULT CURRENT_TIMESTAMP,
@@ -60,6 +61,17 @@ db.exec(`
password TEXT NOT NULL,
created TEXT DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE IF NOT EXISTS resenas (
id TEXT PRIMARY KEY,
localId TEXT NOT NULL,
deviceId TEXT NOT NULL,
puntuacion INTEGER NOT NULL CHECK (puntuacion BETWEEN 1 AND 5),
comentario TEXT,
fecha TEXT DEFAULT CURRENT_TIMESTAMP,
fechaEdicion TEXT,
UNIQUE (localId, deviceId)
);
`);
// Migración suave: si la base de datos ya existía con el esquema antiguo
@@ -86,4 +98,8 @@ for (const table of ["locales", "pendientes"]) {
ensureColumn("locales", "fechaConfirmacion", "TEXT");
db.prepare("UPDATE locales SET fechaConfirmacion = fecha WHERE fechaConfirmacion IS NULL").run();
// Reseñas (issue #6): reportes puede señalar una reseña concreta (nullable;
// null = reporte del local en sí, como hasta ahora).
ensureColumn("reportes", "resenaId", "TEXT");
export default db;
+153 -8
View File
@@ -3,7 +3,7 @@ import { fileURLToPath, pathToFileURL } from "url";
import { dirname, join } from "path";
import { readFileSync } from "fs";
import db from "./db.js";
import { randomUUID } from "crypto";
import { randomUUID, createHash } from "crypto";
const __dirname = dirname(fileURLToPath(import.meta.url));
const app = express();
@@ -53,9 +53,13 @@ if (!ADMIN_PREFIX || ADMIN_PREFIX === "/") {
app.use(express.json());
app.use(express.static(join(__dirname, "../dist")));
// Locales (público, solo lectura)
// Locales (público, solo lectura). Incluye el número de reseñas de cada
// local para que la tarjeta pueda plegar "Reseñas (N)" sin expandir.
app.get("/api/locales", (_req, res) => {
const locales = db.prepare("SELECT * FROM locales ORDER BY fecha DESC").all();
const locales = db.prepare(`
SELECT l.*, (SELECT COUNT(*) FROM resenas WHERE localId = l.id) AS totalResenas
FROM locales l ORDER BY fecha DESC
`).all();
res.json(locales);
});
@@ -167,6 +171,26 @@ app.post(`${ADMIN_PREFIX}/reportes/:id/descartar`, (req, res) => {
res.json({ ok: true });
});
// Reseñas (admin, bajo prefijo configurable): listado completo y borrado de
// moderación. La media del local se recalcula al borrar.
app.get(`${ADMIN_PREFIX}/resenas`, (_req, res) => {
const resenas = db.prepare(`
SELECT r.*, l.nombre AS localNombre, l.provincia AS localProvincia
FROM resenas r LEFT JOIN locales l ON l.id = r.localId
ORDER BY r.fecha DESC
`).all();
res.json(resenas);
});
app.delete(`${ADMIN_PREFIX}/resenas/:id`, (req, res) => {
const { id } = req.params;
const resena = db.prepare("SELECT * FROM resenas WHERE id = ?").get(id);
if (!resena) return res.status(404).json({ error: "Reseña no encontrada" });
db.prepare("DELETE FROM resenas WHERE id = ?").run(id);
recalcularMedia(resena.localId);
res.json({ ok: true });
});
// Confirmar que un local sigue activo (renueva fechaConfirmacion)
app.post("/api/locales/:id/confirmar", (req, res) => {
const { id } = req.params;
@@ -177,20 +201,141 @@ app.post("/api/locales/:id/confirmar", (req, res) => {
res.json({ ok: true, fechaConfirmacion: ahora });
});
// Reportar un local (cerrado / datos incorrectos / inapropiado / otro)
// Reportar un local (cerrado / datos incorrectos / inapropiado / otro) o,
// con resenaId, una reseña concreta de ese local.
app.post("/api/locales/:id/reportar", (req, res) => {
const { id } = req.params;
const { motivo, comentario } = req.body;
const { motivo, comentario, resenaId } = req.body;
const local = db.prepare("SELECT id FROM locales WHERE id = ?").get(id);
if (!local) return res.status(404).json({ error: "Local no encontrado" });
if (resenaId) {
const resena = db.prepare("SELECT id FROM resenas WHERE id = ? AND localId = ?").get(resenaId, id);
if (!resena) return res.status(404).json({ error: "Reseña no encontrada" });
}
const reporteId = randomUUID();
db.prepare(`
INSERT INTO reportes (id, localId, motivo, comentario, fecha, estado)
VALUES (?, ?, ?, ?, ?, 'pendiente')
`).run(reporteId, id, motivo || "otro", comentario || "", new Date().toISOString());
INSERT INTO reportes (id, localId, resenaId, motivo, comentario, fecha, estado)
VALUES (?, ?, ?, ?, ?, ?, 'pendiente')
`).run(reporteId, id, resenaId || null, motivo || "otro", comentario || "", new Date().toISOString());
res.status(201).json({ ok: true, id: reporteId });
});
// --- Reseñas anónimas por local (issue #6) ---
// Identidad v1: deviceId aleatorio del navegador (sin cuentas, estilo 4chan).
// Una reseña por (local, dispositivo) garantizada por UNIQUE; enviar de nuevo
// edita la propia. Publicación directa con filtro de palabras y rate-limit
// por IP como defensa anti-boicot; los reportes y el borrado admin cubren la
// moderación reactiva.
// Rate limit en memoria por IP (ventana 1h). Máximo configurable para pruebas
// (LOCALESP_RESENAS_RATELIMIT_MAX). El DDoS volumétrico se mitiga en el borde,
// no aquí.
const RESENAS_RATELIMIT_MAX = Number(process.env.LOCALESP_RESENAS_RATELIMIT_MAX) || 10;
const RESENAS_RATELIMIT_VENTANA_MS = 60 * 60 * 1000;
const resenasPorIP = new Map();
function limitarEscriturasResenas(req, res, siguiente) {
const ip = req.ip || req.socket?.remoteAddress || "desconocida";
const ahora = Date.now();
const entrada = resenasPorIP.get(ip);
if (entrada && ahora - entrada.inicio < RESENAS_RATELIMIT_VENTANA_MS) {
if (entrada.contador >= RESENAS_RATELIMIT_MAX) {
res.setHeader("Retry-After", Math.ceil((entrada.inicio + RESENAS_RATELIMIT_VENTANA_MS - ahora) / 1000));
return res.status(429).json({ error: "Demasiadas escrituras de reseñas desde esta conexión. Inténtalo de nuevo más tarde." });
}
entrada.contador += 1;
} else {
resenasPorIP.set(ip, { inicio: ahora, contador: 1 });
}
siguiente();
}
// Huella corta por local (estilo 4chan): 3 hex del sha256(deviceId:localId).
// Estable dentro del local, no reversible y no rastreable entre locales.
function huellaCorta(deviceId, localId) {
return "#" + createHash("sha256").update(`${deviceId}:${localId}`).digest("hex").slice(0, 3);
}
// Mantener locales.puntuacion como la media (ROUND) de las reseñas vigentes.
function recalcularMedia(localId) {
const fila = db.prepare("SELECT ROUND(AVG(puntuacion)) AS media FROM resenas WHERE localId = ?").get(localId);
const media = Number(fila?.media) || 0;
db.prepare("UPDATE locales SET puntuacion = ? WHERE id = ?").run(media, localId);
return media;
}
function contienePalabraProhibida(texto) {
const config = db.prepare("SELECT datos FROM config WHERE id = ?").get("filtro_palabras");
if (!config) return false;
const norm = (s) => (s || "").toString().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
const t = norm(texto);
return JSON.parse(config.datos).some((p) => t.includes(norm(p)));
}
// Listar reseñas de un local (público). Con ?deviceId= se marca esPropia.
// Nunca se expone el deviceId completo: solo la huella corta.
app.get("/api/locales/:id/resenas", (req, res) => {
const { id } = req.params;
const local = db.prepare("SELECT id FROM locales WHERE id = ?").get(id);
if (!local) return res.status(404).json({ error: "Local no encontrado" });
const { deviceId } = req.query;
const resenas = db.prepare("SELECT * FROM resenas WHERE localId = ? ORDER BY fecha DESC").all(id)
.map(({ deviceId: d, ...resto }) => ({
...resto,
huella: huellaCorta(d, id),
esPropia: deviceId ? d === deviceId : false,
}));
res.json({ resenas, total: resenas.length });
});
// Crear (201) o editar (200) la reseña del dispositivo en el local (upsert).
app.post("/api/locales/:id/resenas", limitarEscriturasResenas, (req, res) => {
const { id } = req.params;
const local = db.prepare("SELECT id FROM locales WHERE id = ?").get(id);
if (!local) return res.status(404).json({ error: "Local no encontrado" });
const { deviceId, puntuacion, comentario } = req.body || {};
if (typeof deviceId !== "string" || deviceId.length < 8 || deviceId.length > 64) {
return res.status(400).json({ error: "Falta o es inválido el identificador de dispositivo" });
}
const puntos = Number(puntuacion);
if (!Number.isInteger(puntos) || puntos < 1 || puntos > 5) {
return res.status(400).json({ error: "La puntuación debe ser un entero entre 1 y 5" });
}
const comentarioStr = (comentario ?? "").toString().trim();
if (comentarioStr.length > 500) {
return res.status(400).json({ error: "El comentario no puede superar los 500 caracteres" });
}
if (comentarioStr && contienePalabraProhibida(comentarioStr)) {
return res.status(400).json({ error: "El comentario contiene palabras no permitidas" });
}
const existente = db.prepare("SELECT id FROM resenas WHERE localId = ? AND deviceId = ?").get(id, deviceId);
const ahora = new Date().toISOString();
if (existente) {
db.prepare("UPDATE resenas SET puntuacion = ?, comentario = ?, fechaEdicion = ? WHERE id = ?")
.run(puntos, comentarioStr || null, ahora, existente.id);
} else {
db.prepare("INSERT INTO resenas (id, localId, deviceId, puntuacion, comentario, fecha) VALUES (?, ?, ?, ?, ?, ?)")
.run(randomUUID(), id, deviceId, puntos, comentarioStr || null, ahora);
}
const media = recalcularMedia(id);
res.status(existente ? 200 : 201).json({ ok: true, creada: !existente, media, total: db.prepare("SELECT COUNT(*) AS n FROM resenas WHERE localId = ?").get(id).n });
});
// Borrar la reseña propia del dispositivo en el local.
app.delete("/api/locales/:id/resenas", limitarEscriturasResenas, (req, res) => {
const { id } = req.params;
const { deviceId } = req.query;
if (typeof deviceId !== "string" || !deviceId) {
return res.status(400).json({ error: "Falta el identificador de dispositivo" });
}
const existente = db.prepare("SELECT id FROM resenas WHERE localId = ? AND deviceId = ?").get(id, deviceId);
if (!existente) return res.status(404).json({ error: "No hay reseña de este dispositivo en el local" });
db.prepare("DELETE FROM resenas WHERE id = ?").run(existente.id);
const media = recalcularMedia(id);
res.json({ ok: true, media, total: db.prepare("SELECT COUNT(*) AS n FROM resenas WHERE localId = ?").get(id).n });
});
// Config (palabras filtradas)
app.get("/api/config/filtro_palabras", (_req, res) => {
const config = db.prepare("SELECT datos FROM config WHERE id = ?").get("filtro_palabras");
+14 -2
View File
@@ -5,7 +5,7 @@ import {
escucharAuth, loginAdmin, registrarAdmin, cerrarSesion,
suscribirPendientes, aprobarPropuesta, rechazarPropuesta,
suscribirLocales, deleteLocal,
obtenerReportes, descartarReporte,
obtenerReportes, descartarReporte, borrarResenaAdmin,
obtenerPalabrasFiltradas, guardarPalabrasFiltradas,
} from "./firebase.js";
import { obtenerCategoria } from "./constants/categorias.js";
@@ -165,6 +165,16 @@ function PanelAdmin({ email }) {
const rechazar = async (id) => { if (!confirm("¿Rechazar y eliminar esta propuesta?")) return; try { await rechazarPropuesta(id); mostrarToast("Propuesta rechazada", "info"); } catch(e) { mostrarToast("Error: "+e.message, "error"); } };
const eliminar = async (id) => { if (!confirm("¿Eliminar este local publicado?")) return; try { await deleteLocal(id); cargarReportes(); mostrarToast("Local eliminado", "info"); } catch(e) { mostrarToast("Error: "+e.message, "error"); } };
const descartar = async (id) => { try { await descartarReporte(id); setReportes(r => r.filter(x => x.id !== id)); mostrarToast("Aviso descartado", "info"); } catch(e) { mostrarToast("Error: "+e.message, "error"); } };
// Moderación de reseñas (issue #6): al borrar la reseña reportada se
// descarta también el aviso (queda resuelto).
const borrarResenaReportada = async (resenaId, reporteId) => {
try {
await borrarResenaAdmin(resenaId);
await descartarReporte(reporteId);
setReportes(r => r.filter(x => x.id !== reporteId));
mostrarToast("Reseña eliminada", "exito");
} catch(e) { mostrarToast("Error: "+e.message, "error"); }
};
const addPalabra = () => {
const p = nuevaP.trim().toLowerCase();
@@ -279,13 +289,15 @@ function PanelAdmin({ email }) {
<div style={{ display:"flex", alignItems:"center", gap:8, flexWrap:"wrap", marginBottom:6 }}>
<span style={{ fontWeight:700, fontSize:16 }}>{r.localNombre || "(local ya eliminado)"}</span>
<span style={S.badge("#C0392B", "#FDEDEC")}>{{ cerrado:"Ha cerrado", datos_incorrectos:"Datos incorrectos", inapropiado:"Contenido inapropiado", otro:"Otro motivo" }[r.motivo] || r.motivo}</span>
{r.resenaId && <span style={S.badge("#8B4513", "#FDF2E9")}>Reseña</span>}
</div>
<p style={{ margin:0, fontSize:13, color:"#666" }}>📍 {r.localProvincia} {r.localDireccion ? `· ${r.localDireccion}` : ""}</p>
{r.comentario && <p style={{ margin:"8px 0 0", fontSize:13, color:"#666", fontStyle:"italic", background:"#FAFAFA", padding:"8px 12px", borderRadius:8 }}>"{r.comentario}"</p>}
<p style={{ margin:"6px 0 0", fontSize:11, color:"#AAA" }}>Reportado: {new Date(r.fecha).toLocaleDateString("es-ES", { day:"numeric", month:"short", hour:"2-digit", minute:"2-digit" })}</p>
</div>
<div style={{ display:"flex", gap:8, flexShrink:0 }}>
{r.localId && <button onClick={() => eliminar(r.localId)} style={{ ...S.btn("#C0392B"), padding:"8px 16px", fontSize:13 }}>🗑 Eliminar local</button>}
{r.resenaId && <button onClick={() => borrarResenaReportada(r.resenaId, r.id)} style={{ ...S.btn("#C0392B"), padding:"8px 16px", fontSize:13 }}>🗑 Borrar reseña</button>}
{r.localId && !r.resenaId && <button onClick={() => eliminar(r.localId)} style={{ ...S.btn("#C0392B"), padding:"8px 16px", fontSize:13 }}>🗑 Eliminar local</button>}
<button onClick={() => descartar(r.id)} style={{ ...S.btn("#EEE","#666"), padding:"8px 16px", fontSize:13 }}>Descartar aviso</button>
</div>
</div>
+45 -2
View File
@@ -97,15 +97,58 @@ export async function confirmarLocal(id) {
return response.json();
}
export async function reportarLocal(id, motivo, comentario) {
export async function reportarLocal(id, motivo, comentario, resenaId) {
const response = await fetch(`${API_URL}/locales/${id}/reportar`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ motivo, comentario }),
body: JSON.stringify({ motivo, comentario, resenaId }),
});
return response.json();
}
// --- Reseñas anónimas por local (issue #6) ---
// Identidad v1: deviceId del navegador. Con ?deviceId= el servidor marca
// esPropia en cada reseña (para precargar el formulario) sin exponer el
// deviceId completo (solo la huella corta por local).
export async function listarResenas(localId, deviceId) {
const q = deviceId ? `?deviceId=${encodeURIComponent(deviceId)}` : "";
const response = await fetch(`${API_URL}/locales/${localId}/resenas${q}`);
return response.json();
}
// Crear o editar (upsert) la reseña del dispositivo en el local.
export async function enviarResena(localId, { deviceId, puntuacion, comentario }) {
const response = await fetch(`${API_URL}/locales/${localId}/resenas`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ deviceId, puntuacion, comentario }),
});
const datos = await response.json().catch(() => ({}));
if (!response.ok) throw new Error(datos.error || "No se pudo guardar la reseña");
return datos;
}
// Borrar la reseña propia del dispositivo en el local.
export async function borrarResena(localId, deviceId) {
const response = await fetch(`${API_URL}/locales/${localId}/resenas?deviceId=${encodeURIComponent(deviceId)}`, {
method: "DELETE",
});
const datos = await response.json().catch(() => ({}));
if (!response.ok) throw new Error(datos.error || "No se pudo borrar la reseña");
return datos;
}
// Moderación: listado completo y borrado de cualquier reseña (admin).
export async function obtenerResenas() {
const response = await fetch(`${ADMIN_URL}/resenas`);
return response.json();
}
export async function borrarResenaAdmin(id) {
const response = await fetch(`${ADMIN_URL}/resenas/${id}`, { method: "DELETE" });
return response.json();
}
export async function obtenerReportes() {
const response = await fetch(`${ADMIN_URL}/reportes`);
return response.json();
+9 -2
View File
@@ -1,6 +1,6 @@
import { useState } from "react";
import CategoriaBadge from "./CategoriaBadge.jsx";
import StarRating from "./StarRating.jsx";
import ResenasLocal from "./ResenasLocal.jsx";
import ReportarLocal from "./ReportarLocal.jsx";
import Toast from "./Toast.jsx";
import useFavoritos from "../hooks/useFavoritos.js";
@@ -134,7 +134,14 @@ export default function LocalCard({ local, distanciaKm }) {
</div>
)}
<StarRating value={local.puntuacion} readOnly />
{/* Media de reseñas + sección desplegable "Reseñas (N)" (issue #6).
totalResenas lo aporta GET /api/locales; tras escribir, la cabecera
se actualiza en local y el listado general llega por el polling. */}
<ResenasLocal
localId={local.id}
totalInicial={local.totalResenas || 0}
mediaInicial={local.puntuacion || 0}
/>
{local.descripcion && (
<p style={{ fontSize: 13, color: "var(--color-text-secondary)", margin: 0, fontStyle: "italic" }}>"{local.descripcion}"</p>
+235
View File
@@ -0,0 +1,235 @@
import { useState } from "react";
import StarRating from "./StarRating.jsx";
import { borrarResena, enviarResena, listarResenas, reportarLocal } from "../firebase.js";
import { obtenerDeviceId } from "../utils/dispositivo.js";
const MAX_COMENTARIO = 500;
function formatearFecha(fecha) {
const d = new Date(fecha);
return Number.isNaN(d.getTime()) ? "" : d.toLocaleDateString("es-ES", { day: "numeric", month: "short", year: "numeric" });
}
// Sección desplegable de reseñas anónimas (issue #6): cabecera plegable
// "Reseñas (N) · ★media" sobre la propia tarjeta, con carga perezosa de la
// lista al expandir y formulario inline. Una reseña por dispositivo (el
// servidor hace upsert): la propia se precarga y permite actualizar o
// borrar; las ajenas se pueden reportar. Identidad anónima con huella corta
// por local ("Anónimo #a3f"), sin datos personales.
export default function ResenasLocal({ localId, totalInicial = 0, mediaInicial = 0 }) {
const [abierto, setAbierto] = useState(false);
const [resenas, setResenas] = useState(null); // null = aún sin cargar
const [cargando, setCargando] = useState(false);
const [total, setTotal] = useState(totalInicial);
const [media, setMedia] = useState(mediaInicial);
const [tienePropia, setTienePropia] = useState(false);
const [puntuacion, setPuntuacion] = useState(0);
const [comentario, setComentario] = useState("");
const [enviando, setEnviando] = useState(false);
const [error, setError] = useState("");
const [reportada, setReportada] = useState(null);
const cargar = async () => {
setCargando(true);
setError("");
try {
const datos = await listarResenas(localId, obtenerDeviceId());
setResenas(datos.resenas || []);
setTotal(datos.total || 0);
const propia = (datos.resenas || []).find((r) => r.esPropia);
setTienePropia(!!propia);
setPuntuacion(propia?.puntuacion || 0);
setComentario(propia?.comentario || "");
} catch (e) {
console.error(e);
setError("No se pudieron cargar las reseñas.");
}
setCargando(false);
};
const alternar = () => {
const nuevo = !abierto;
setAbierto(nuevo);
if (nuevo && resenas === null && !cargando) cargar();
};
const enviar = async () => {
if (puntuacion < 1) return;
setEnviando(true);
setError("");
try {
const datos = await enviarResena(localId, {
deviceId: obtenerDeviceId(),
puntuacion,
comentario: comentario.trim(),
});
setMedia(datos.media ?? media);
setTienePropia(true);
await cargar();
} catch (e) {
setError(e.message || "No se pudo guardar la reseña.");
}
setEnviando(false);
};
const borrar = async () => {
setEnviando(true);
setError("");
try {
const datos = await borrarResena(localId, obtenerDeviceId());
setMedia(datos.media ?? media);
setTienePropia(false);
setPuntuacion(0);
setComentario("");
await cargar();
} catch (e) {
setError(e.message || "No se pudo borrar la reseña.");
}
setEnviando(false);
};
const reportar = async (resena) => {
try {
await reportarLocal(localId, "inapropiado", "", resena.id);
setReportada(resena.id);
} catch (e) {
console.error(e);
}
};
return (
<div style={{ display: "flex", flexDirection: "column", gap: 8 }}>
{/* Cabecera plegable: media + número de reseñas */}
<button
type="button"
onClick={alternar}
aria-expanded={abierto}
style={{
display: "flex", alignItems: "center", gap: 8, width: "fit-content",
background: "none", border: "none", padding: 0, cursor: "pointer",
fontSize: 12, color: "var(--color-text-secondary)",
}}
>
<StarRating value={media} readOnly size={14} />
<span>
Reseñas ({total})
<i
className={`ti ${abierto ? "ti-chevron-up" : "ti-chevron-down"}`}
aria-hidden="true"
style={{ fontSize: 13, marginLeft: 4, color: "var(--color-text-tertiary)" }}
/>
</span>
</button>
{abierto && (
<div style={{ display: "flex", flexDirection: "column", gap: 10 }}>
{cargando && resenas === null && (
<p style={{ fontSize: 12, color: "var(--color-text-tertiary)", margin: 0 }}>Cargando reseñas…</p>
)}
{/* Lista de reseñas */}
{resenas !== null && resenas.length === 0 && (
<p style={{ fontSize: 12, color: "var(--color-text-tertiary)", margin: 0 }}>
Aún no hay reseñas. ¡Sé el primero!
</p>
)}
{resenas !== null && resenas.map((r) => (
<div key={r.id} style={{
background: "var(--color-background-secondary)",
borderRadius: "var(--border-radius-md)",
padding: "8px 10px",
border: r.esPropia ? "0.5px solid var(--color-border-secondary)" : "none",
}}>
<div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", gap: 6 }}>
<span style={{ fontSize: 12, color: "var(--color-text-secondary)" }}>
Anónimo {r.huella} · {formatearFecha(r.fecha)}
{r.fechaEdicion && <span style={{ color: "var(--color-text-tertiary)" }}> · editada</span>}
</span>
<span style={{ display: "flex", alignItems: "center", gap: 6 }}>
{r.esPropia
? <span style={{ fontSize: 11, color: "#8B0000", fontWeight: 500 }}>tu reseña</span>
: reportada === r.id
? <span style={{ fontSize: 11, color: "#1E8449" }}>✅ reportada</span>
: (
<button type="button" onClick={() => reportar(r)} title="Reportar esta reseña"
style={{ background: "none", border: "none", padding: 0, cursor: "pointer", fontSize: 12, color: "var(--color-text-tertiary)" }}>
<i className="ti ti-flag" aria-hidden="true"></i>
</button>
)}
</span>
</div>
<div style={{ marginTop: 2 }}>
<StarRating value={r.puntuacion} readOnly size={13} />
</div>
{r.comentario && (
<p style={{ margin: "4px 0 0", fontSize: 13, color: "var(--color-text-secondary)" }}>{r.comentario}</p>
)}
</div>
))}
{/* Formulario inline: crear o actualizar la reseña propia */}
<div style={{
background: "var(--color-background-primary)",
border: "0.5px solid var(--color-border-tertiary)",
borderRadius: "var(--border-radius-md)",
padding: "8px 10px",
display: "flex", flexDirection: "column", gap: 6,
}}>
<p style={{ margin: 0, fontSize: 12, fontWeight: 500 }}>
{tienePropia ? "Tu reseña (anónima)" : "Deja tu reseña (anónima)"}
</p>
<StarRating value={puntuacion} onChange={setPuntuacion} size={20} />
<textarea
value={comentario}
onChange={(e) => setComentario(e.target.value)}
maxLength={MAX_COMENTARIO}
rows={2}
placeholder="Comentario opcional (máx. 500 caracteres)…"
aria-label="Comentario de la reseña"
style={{
fontSize: 12, padding: "5px 8px", borderRadius: "var(--border-radius-md)",
border: "0.5px solid var(--color-border-secondary)",
background: "var(--color-background-primary)", color: "var(--color-text-primary)",
resize: "vertical", fontFamily: "inherit",
}}
/>
{error && (
<p role="alert" style={{ margin: 0, fontSize: 12, color: "#922B21" }}>
<i className="ti ti-alert-triangle" aria-hidden="true"></i> {error}
</p>
)}
<div style={{ display: "flex", gap: 6, alignItems: "center" }}>
<button
type="button"
onClick={enviar}
disabled={puntuacion < 1 || enviando}
style={{
fontSize: 12, background: puntuacion >= 1 ? "#8B0000" : "var(--color-background-secondary)",
color: puntuacion >= 1 ? "white" : "var(--color-text-tertiary)",
border: "none", borderRadius: "var(--border-radius-md)", padding: "5px 12px",
cursor: puntuacion >= 1 && !enviando ? "pointer" : "not-allowed", fontWeight: 500,
}}
>
{enviando ? "Guardando…" : tienePropia ? "Actualizar" : "Publicar"}
</button>
{tienePropia && (
<button
type="button"
onClick={borrar}
disabled={enviando}
style={{
fontSize: 12, background: "none", border: "0.5px solid var(--color-border-secondary)",
borderRadius: "var(--border-radius-md)", padding: "5px 12px", cursor: "pointer",
color: "var(--color-text-secondary)",
}}
>
Borrar mi reseña
</button>
)}
</div>
</div>
</div>
)}
</div>
);
}
+5
View File
@@ -8,6 +8,11 @@ export {
deleteLocal,
confirmarLocal,
reportarLocal,
listarResenas,
enviarResena,
borrarResena,
obtenerResenas,
borrarResenaAdmin,
obtenerReportes,
descartarReporte,
enviarPropuesta,
+19
View File
@@ -0,0 +1,19 @@
// Identidad anónima v1 para las reseñas (issue #6): un identificador de
// dispositivo aleatorio persistido en localStorage. Sin datos personales y
// sin cuentas ("estilo 4chan"); cuando lleguen las cuentas se migrará
// deviceId -> userId (ver design de resenas-por-local).
const CLAVE = "localesp_device_id";
export function obtenerDeviceId() {
try {
let id = localStorage.getItem(CLAVE);
if (!id) {
id = globalThis.crypto?.randomUUID?.() || `dev-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
localStorage.setItem(CLAVE, id);
}
return id;
} catch {
// Almacenamiento no disponible (p. ej. modo privado): identidad efímera.
return `eph-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
}
}
+108
View File
@@ -0,0 +1,108 @@
// @vitest-environment jsdom
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
// Mock del cliente API (firebase.js re-exporta api.js: el mock intercepta la
// resolución del módulo y cubre ambas vías).
vi.mock("../../src/api.js", () => ({
listarResenas: vi.fn(),
enviarResena: vi.fn(),
borrarResena: vi.fn(),
reportarLocal: vi.fn(),
}));
import ResenasLocal from "../../src/components/ResenasLocal.jsx";
import { borrarResena, enviarResena, listarResenas, reportarLocal } from "../../src/api.js";
beforeEach(() => {
vi.clearAllMocks();
localStorage.clear();
});
afterEach(cleanup);
const RESENA_AJENA = {
id: "res-1111", huella: "#a1b2c3", puntuacion: 4, comentario: "Genial",
fecha: "2026-10-11T10:00:00.000Z", fechaEdicion: null, esPropia: false,
};
const RESENA_PROPIA = {
id: "res-2222", huella: "#d4e5f6", puntuacion: 5, comentario: "Mi favorito",
fecha: "2026-10-10T10:00:00.000Z", fechaEdicion: null, esPropia: true,
};
const abrir = () => fireEvent.click(screen.getByRole("button", { name: /reseñas/i }));
describe("ResenasLocal (sección desplegable en la tarjeta)", () => {
it("plegado muestra media y número, sin cargar nada; aria-expanded refleja el estado", () => {
render(<ResenasLocal localId="loc-1" totalInicial={3} mediaInicial={4} />);
const cabecera = screen.getByRole("button", { name: /reseñas \(3\)/i });
expect(cabecera.getAttribute("aria-expanded")).toBe("false");
expect(listarResenas).not.toHaveBeenCalled();
});
it("al expandir carga perezosamente la lista (huella anónima, estrellas, comentario)", async () => {
listarResenas.mockResolvedValue({ resenas: [RESENA_AJENA], total: 1 });
render(<ResenasLocal localId="loc-1" totalInicial={1} mediaInicial={4} />);
abrir();
await waitFor(() => expect(listarResenas).toHaveBeenCalledWith("loc-1", expect.any(String)));
expect(await screen.findByText(/anónimo #a1b2c3/i)).toBeTruthy();
expect(screen.getByText("Genial")).toBeTruthy();
// estrellas de la reseña (la cabecera también es role=img con la media)
expect(screen.getAllByRole("img", { name: /valoración: 4 de 5/i }).length).toBeGreaterThan(0);
// el deviceId se genera y persiste en localStorage
expect(localStorage.getItem("localesp_device_id")).toMatch(/./);
});
it("formulario: elegir estrellas y publicar llama a enviarResena con el deviceId", async () => {
listarResenas.mockResolvedValue({ resenas: [], total: 0 });
enviarResena.mockResolvedValue({ ok: true, media: 5, total: 1 });
render(<ResenasLocal localId="loc-1" />);
abrir();
fireEvent.click(await screen.findByRole("radio", { name: "4 estrellas" }));
fireEvent.change(screen.getByLabelText(/comentario de la reseña/i), { target: { value: "Muy bien" } });
fireEvent.click(screen.getByRole("button", { name: /publicar/i }));
await waitFor(() => expect(enviarResena).toHaveBeenCalledWith("loc-1", {
deviceId: expect.any(String),
puntuacion: 4,
comentario: "Muy bien",
}));
});
it("la reseña propia se precarga: botón Actualizar y Borrar mi reseña", async () => {
listarResenas.mockResolvedValue({ resenas: [RESENA_PROPIA], total: 1 });
borrarResena.mockResolvedValue({ ok: true, media: 0, total: 0 });
render(<ResenasLocal localId="loc-1" totalInicial={1} mediaInicial={5} />);
abrir();
expect(await screen.findByText(/tu reseña/i)).toBeTruthy();
expect(screen.getByRole("button", { name: /actualizar/i })).toBeTruthy();
expect(screen.getByLabelText(/comentario de la reseña/i).value).toBe("Mi favorito");
fireEvent.click(screen.getByRole("button", { name: /borrar mi reseña/i }));
await waitFor(() => expect(borrarResena).toHaveBeenCalledWith("loc-1", expect.any(String)));
});
it("las reseñas ajenas se pueden reportar (reportarLocal con resenaId)", async () => {
listarResenas.mockResolvedValue({ resenas: [RESENA_AJENA], total: 1 });
reportarLocal.mockResolvedValue({ ok: true });
render(<ResenasLocal localId="loc-1" />);
abrir();
fireEvent.click(await screen.findByTitle(/reportar esta reseña/i));
await waitFor(() => expect(reportarLocal).toHaveBeenCalledWith("loc-1", "inapropiado", "", "res-1111"));
expect(await screen.findByText(/✅ reportada/i)).toBeTruthy();
});
it("errores del servidor (palabras no permitidas, 429) se muestran como aviso", async () => {
listarResenas.mockResolvedValue({ resenas: [], total: 0 });
enviarResena.mockRejectedValue(new Error("El comentario contiene palabras no permitidas"));
render(<ResenasLocal localId="loc-1" />);
abrir();
fireEvent.click(await screen.findByRole("radio", { name: "3 estrellas" }));
fireEvent.click(screen.getByRole("button", { name: /publicar/i }));
expect((await screen.findByRole("alert")).textContent).toMatch(/no permitidas/i);
});
});
+54
View File
@@ -0,0 +1,54 @@
import { expect, beforeAll, describe, it } from "vitest";
import request from "supertest";
// Rate-limit de reseñas con su PROPIA instancia de app y un máximo bajo,
// para poder agotar la cuota sin interferir en otras suites (vitest aísla
// los módulos por fichero).
process.env.LOCALESP_DB = ":memory:";
process.env.LOCALESP_ADMIN_PREFIX = "/prefijo-admin-rl";
process.env.LOCALESP_RESENAS_RATELIMIT_MAX = "2";
const server = (await import("../../server/index.js")).default;
const PREFIX = "/prefijo-admin-rl";
let localId;
beforeAll(async () => {
const propuesta = await request(server)
.post("/api/propuestas")
.send({ nombre: "Bar Limitado", provincia: "Madrid" })
.expect(201);
await request(server).post(`${PREFIX}/aprobar/${propuesta.body.id}`).expect(200);
const locales = (await request(server).get("/api/locales").expect(200)).body;
localId = locales.find((l) => l.nombre === "Bar Limitado").id;
});
describe("Rate limit de escrituras de reseñas (anti-boicot base)", () => {
it("las dos primeras escrituras pasan y la tercera recibe 429", async () => {
await request(server)
.post(`/api/locales/${localId}/resenas`)
.send({ deviceId: "device-rl-aaaa-0001", puntuacion: 5 })
.expect(201);
await request(server)
.post(`/api/locales/${localId}/resenas`)
.send({ deviceId: "device-rl-aaaa-0001", puntuacion: 4 }) // edición
.expect(200);
const tercera = await request(server)
.post(`/api/locales/${localId}/resenas`)
.send({ deviceId: "device-rl-bbbb-0002", puntuacion: 3 });
expect(tercera.status).toBe(429);
expect(tercera.body.error).toBeTruthy();
expect(tercera.headers["retry-after"]).toBeTruthy();
// el DELETE también está limitado…
const borrado = await request(server)
.delete(`/api/locales/${localId}/resenas?deviceId=device-rl-aaaa-0001`);
expect(borrado.status).toBe(429);
// …pero la LECTURA sigue disponible
const lista = await request(server).get(`/api/locales/${localId}/resenas`).expect(200);
expect(lista.body.total).toBe(1);
});
});
+170
View File
@@ -0,0 +1,170 @@
import request from "supertest";
// BD en memoria, prefijo admin y rate-limit holgado para las pruebas de
// comportamiento (el límite se prueba aparte, con su propio proceso):
// deben configurarse ANTES de importar la app.
process.env.LOCALESP_DB = ":memory:";
process.env.LOCALESP_ADMIN_PREFIX = "/prefijo-admin-test";
process.env.LOCALESP_RESENAS_RATELIMIT_MAX = "100";
// Se importa después de fijar las variables de entorno.
const server = (await import("../../server/index.js")).default;
const PREFIX = "/prefijo-admin-test";
const DEV_A = "device-aaaaaaaa-1111";
const DEV_B = "device-bbbbbbbb-2222";
let localId;
beforeAll(async () => {
// Publicar un local (propuesta → aprobación) para tener dónde reseñar.
const propuesta = await request(server)
.post("/api/propuestas")
.send({ nombre: "Bar Reseñable", provincia: "Madrid", categoria: "Restauración" })
.expect(201);
await request(server).post(`${PREFIX}/aprobar/${propuesta.body.id}`).expect(200);
const locales = (await request(server).get("/api/locales").expect(200)).body;
localId = locales.find((l) => l.nombre === "Bar Reseñable").id;
});
describe("Reseñas — creación, upsert y listado público", () => {
it("GET /api/locales incluye totalResenas por local", async () => {
const locales = (await request(server).get("/api/locales").expect(200)).body;
const bar = locales.find((l) => l.id === localId);
expect(bar.totalResenas).toBe(0);
});
it("POST crea la reseña (201) y recalcula la media; GET lista con huella y sin deviceId", async () => {
const res = await request(server)
.post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_A, puntuacion: 5, comentario: " Pan excelente " })
.expect(201);
expect(res.body.creada).toBe(true);
expect(res.body.media).toBe(5);
expect(res.body.total).toBe(1);
const lista = (await request(server).get(`/api/locales/${localId}/resenas`).expect(200)).body;
expect(lista.total).toBe(1);
const [r] = lista.resenas;
expect(r.huella).toMatch(/^#[0-9a-f]{3}$/);
expect(r.puntuacion).toBe(5);
expect(r.comentario).toBe("Pan excelente"); // trim
expect(r.deviceId).toBeUndefined(); // nunca se expone
expect(r.esPropia).toBe(false); // sin ?deviceId=
// con ?deviceId= se marca la propia
const propia = (await request(server).get(`/api/locales/${localId}/resenas?deviceId=${DEV_A}`).expect(200)).body;
expect(propia.resenas[0].esPropia).toBe(true);
// y la media queda en el local
const local = (await request(server).get("/api/locales").expect(200)).body.find((l) => l.id === localId);
expect(local.puntuacion).toBe(5);
expect(local.totalResenas).toBe(1);
});
it("POST del mismo dispositivo edita (200, fechaEdicion) sin duplicar", async () => {
const res = await request(server)
.post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_A, puntuacion: 4, comentario: "Bajó algo el nivel" })
.expect(200);
expect(res.body.creada).toBe(false);
expect(res.body.total).toBe(1); // sigue habiendo UNA reseña
const lista = (await request(server).get(`/api/locales/${localId}/resenas?deviceId=${DEV_A}`)).body;
expect(lista.resenas).toHaveLength(1);
expect(lista.resenas[0].fechaEdicion).toBeTruthy();
expect(lista.resenas[0].comentario).toBe("Bajó algo el nivel");
});
it("la media se recalcula al crear, editar y borrar (ROUND de SQLite)", async () => {
// estado: DEV_A=4 → añade DEV_B=5 → media ROUND(4.5)=5
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_B, puntuacion: 5 }).expect(201);
expect((await request(server).get("/api/locales")).body.find((l) => l.id === localId).puntuacion).toBe(5);
// edita DEV_B a 1 → media ROUND(2.5)=3 (round half away from zero)
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_B, puntuacion: 1 }).expect(200);
expect((await request(server).get("/api/locales")).body.find((l) => l.id === localId).puntuacion).toBe(3);
// borra DEV_B → solo queda DEV_A=4
await request(server).delete(`/api/locales/${localId}/resenas?deviceId=${DEV_B}`).expect(200);
expect((await request(server).get("/api/locales")).body.find((l) => l.id === localId).puntuacion).toBe(4);
});
it("DELETE de la propia reseña inexistente → 404; sin deviceId → 400", async () => {
await request(server).delete(`/api/locales/${localId}/resenas?deviceId=${DEV_B}`).expect(404);
await request(server).delete(`/api/locales/${localId}/resenas`).expect(400);
});
});
describe("Reseñas — validaciones del contrato", () => {
it("400: puntuacion ausente, 0, 6, no entera", async () => {
for (const puntuacion of [undefined, 0, 6, 3.5, "cuatro"]) {
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_B, puntuacion }).expect(400);
}
});
it("400: deviceId ausente/corto/largo y comentario >500", async () => {
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: "", puntuacion: 3 }).expect(400);
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ puntuacion: 3 }).expect(400);
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: "x".repeat(65), puntuacion: 3 }).expect(400);
await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_B, puntuacion: 3, comentario: "y".repeat(501) }).expect(400);
});
it("404: local inexistente en GET/POST", async () => {
const idFantasma = "00000000-0000-4000-8000-000000000000";
await request(server).get(`/api/locales/${idFantasma}/resenas`).expect(404);
await request(server).post(`/api/locales/${idFantasma}/resenas`)
.send({ deviceId: DEV_B, puntuacion: 3 }).expect(404);
});
it("400: comentario con palabra prohibida (filtro de palabras)", async () => {
await request(server).post("/api/config/filtro_palabras")
.send({ palabras: ["timonestro"] }).expect(200);
const res = await request(server).post(`/api/locales/${localId}/resenas`)
.send({ deviceId: DEV_B, puntuacion: 1, comentario: "Sitio timonestro" }).expect(400);
expect(res.body.error).toMatch(/no permitidas/i);
// la reseña no se creó ni modificó
const lista = (await request(server).get(`/api/locales/${localId}/resenas`)).body;
expect(lista.resenas.some((r) => r.comentario?.includes("timonestro"))).toBe(false);
await request(server).post("/api/config/filtro_palabras").send({ palabras: [] });
});
});
describe("Reseñas — reportes y moderación admin", () => {
it("reportar una reseña concreta (resenaId) llega a la lista admin", async () => {
const lista = (await request(server).get(`/api/locales/${localId}/resenas`)).body;
const objetivo = lista.resenas[0];
await request(server).post(`/api/locales/${localId}/reportar`)
.send({ motivo: "inapropiado", comentario: "", resenaId: objetivo.id })
.expect(201);
const reportes = (await request(server).get(`${PREFIX}/reportes`).expect(200)).body;
const reporte = reportes.find((r) => r.resenaId === objetivo.id);
expect(reporte).toBeDefined();
expect(reporte.localNombre).toBe("Bar Reseñable");
// resenaId que no existe → 404
await request(server).post(`/api/locales/${localId}/reportar`)
.send({ resenaId: "no-existe" }).expect(404);
});
it("admin: listado completo y borrado con recálculo de media", async () => {
const resenas = (await request(server).get(`${PREFIX}/resenas`).expect(200)).body;
expect(resenas).toHaveLength(1);
expect(resenas[0].localNombre).toBe("Bar Reseñable");
await request(server).delete(`${PREFIX}/resenas/${resenas[0].id}`).expect(200);
// sin reseñas → media 0
expect((await request(server).get("/api/locales")).body.find((l) => l.id === localId).puntuacion).toBe(0);
// borrar de nuevo → 404
await request(server).delete(`${PREFIX}/resenas/${resenas[0].id}`).expect(404);
});
});