use std::collections::HashMap;
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
{% set refs = fields | filter(attribute="is_ref", value=true) %}use async_trait::async_trait;
use dominio_{{ snake }}::{
modelo::{{ "{" }}{{ pascal }}, Id{{ pascal }}},
repositorio::{% if refs %}{{ "{" }}Filtro{{ pascal }}, Repositorio{{ pascal }}}{% else %}Repositorio{{ pascal }}{% endif %},
};
use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};
/// Guarda {{ plural }} en la memoria del proceso: se pierden cuando el proceso se para.
/// Como el adaptador de Postgres, oculta las filas borradas y lista {% if order_by == "creado_en DESC, id" %}primero las más recientes{% else %}en el orden de `puerto.toml`
/// (`{{ order_by }}`; los textos, por bytes y no con la collation de Postgres){% endif %}{% set uniques = fields | filter(attribute="unique", value=true) %}{% if unique_conditions %};
/// un valor único que ya tiene otra fila viva es `Duplicado`{% endif %}.
/// Cubre el hueco hasta que haya base de datos (`puerto nuevo --db` genera repositorios Postgres).
#[derive(Default)]
pub struct Repositorio{{ pascal }}EnMemoria {
filas: RwLock<HashMap<Id{{ pascal }}, {{ pascal }}>>,
}
impl Repositorio{{ pascal }}EnMemoria {
pub fn new() -> Self {
Self::default()
}
// Un cerrojo envenenado significa que un escritor hizo panic; cada escritura es un solo
// insert, así que el mapa sigue entero y se usa tal cual.
fn leer(&self) -> RwLockReadGuard<'_, HashMap<Id{{ pascal }}, {{ pascal }}>> {
self.filas.read().unwrap_or_else(PoisonError::into_inner)
}
fn escribir(&self) -> RwLockWriteGuard<'_, HashMap<Id{{ pascal }}, {{ pascal }}>> {
self.filas.write().unwrap_or_else(PoisonError::into_inner)
}
}
#[async_trait]
impl Repositorio{{ pascal }} for Repositorio{{ pascal }}EnMemoria {
async fn buscar_todos(&self, pagina: PeticionPagina{% if refs %}, filtro: Filtro{{ pascal }}{% endif %}) -> Result<Pagina<{{ pascal }}>, ErrorRepositorio> {
tracing::debug!(limite = pagina.limite(), desplazamiento = pagina.desplazamiento(), "buscar_todos");
let filas = self.leer();
let mut vivos: Vec<&{{ pascal }}> = filas
.values()
.filter(|fila| !fila.borrado)
{% for r in refs %} .filter(|fila| filtro.{{ r.name }}.is_none_or(|id| fila.{{ r.name }} == {% if r.field_type is starting_with("Option<") %}Some(id){% else %}id{% endif %}))
{% endfor %} .collect();
vivos.sort_by(|a, b| {{ "{" }}
{{ order_chain }}
});
let total = vivos.len() as u64;
let elementos = vivos
.into_iter()
.skip(pagina.desplazamiento() as usize)
.take(pagina.limite() as usize)
.cloned()
.collect();
Ok(Pagina::new(elementos, total, pagina))
}
async fn buscar_por_id(&self, id: Id{{ pascal }}) -> Result<Option<{{ pascal }}>, ErrorRepositorio> {
tracing::debug!(%id, "buscar_por_id");
Ok(self.leer().get(&id).filter(|fila| !fila.borrado).cloned())
}
async fn guardar(&self, entidad: &{{ pascal }}) -> Result<(), ErrorRepositorio> {
tracing::debug!(id = %entidad.id, "guardar");
let mut filas = self.escribir();
{% if unique_conditions %} // Como los índices únicos parciales: solo las filas vivas ocupan sus valores.
let ocupado = !entidad.borrado
&& filas.values().any(|fila| {
fila.id != entidad.id
&& !fila.borrado
&& {% if unique_conditions | length > 1 %}({% endif %}{{ unique_conditions | join(sep=" || ") }}{% if unique_conditions | length > 1 %}){% endif %}
});
if ocupado {
tracing::warn!(id = %entidad.id, "guardar rechazado: un valor único ya está ocupado");
return Err(ErrorRepositorio::Duplicado);
}
{% endif %} filas.insert(entidad.id, entidad.clone());
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
{% if seeded %} use dominio_{{ snake }}::modelo::Props{{ pascal }};
{% endif %}{% if seeded | length < fields | length %} use dominio_{{ snake }}::pruebas::madres::Madre{{ pascal }};
{% endif %}{% for import in test_imports %} use {{ import }};
{% endfor %}
/// Una entidad válida, con los valores de la madre{% if seeded %} salvo en los campos únicos (uno
/// nuevo cada vez) y las fechas (un segundo exacto){% endif %}.
fn nuevo_{{ snake }}() -> {{ pascal }} {
{% if seeded %}{{ pascal }}::new(Props{{ pascal }} {
{% for f in fields %}{% if f.name in seeded %} {{ f.name }}: {{ f.seed_literal }},
{% endif %}{% endfor %}{% if seeded | length < fields | length %} ..Madre{{ pascal }}::new().construir_props()
{% endif %} })
.unwrap(){% else %}Madre{{ pascal }}::aleatorio(){% endif %}
}
#[tokio::test]
async fn deberia_encontrar_{{ snake }}_por_id_tras_guardar() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let entidad = nuevo_{{ snake }}();
repositorio.guardar(&entidad).await.unwrap();
// Actuar
let encontrado = repositorio.buscar_por_id(entidad.id).await.unwrap();
// Comprobar
assert_eq!(encontrado.map(|fila| fila.id), Some(entidad.id));
}
#[tokio::test]
async fn deberia_actualizar_la_fila_cuando_se_guarda_de_nuevo() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let mut entidad = nuevo_{{ snake }}();
repositorio.guardar(&entidad).await.unwrap();
entidad.actualizado_en = chrono::Utc::now();
// Actuar
repositorio.guardar(&entidad).await.unwrap();
// Comprobar
let pagina = repositorio.buscar_todos(PeticionPagina::default(){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();
assert_eq!(pagina.total, 1);
assert_eq!(pagina.elementos[0].actualizado_en, entidad.actualizado_en);
}
#[tokio::test]
async fn no_deberia_encontrar_{{ snake }}_tras_su_borrado() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let mut entidad = nuevo_{{ snake }}();
entidad.borrado = true;
entidad.borrado_en = Some(entidad.actualizado_en);
repositorio.guardar(&entidad).await.unwrap();
// Actuar
let encontrado = repositorio.buscar_por_id(entidad.id).await.unwrap();
let pagina = repositorio.buscar_todos(PeticionPagina::default(){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();
// Comprobar
assert!(encontrado.is_none());
assert_eq!(pagina.total, 0);
}
#[tokio::test]
async fn deberia_devolver_la_pagina_pedida_de_una_lista_mayor() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
for _ in 0..3 {
repositorio.guardar(&nuevo_{{ snake }}()).await.unwrap();
}
// Actuar
let pagina = repositorio.buscar_todos(PeticionPagina::new(Some(2), Some(2)){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();
// Comprobar
assert_eq!(pagina.elementos.len(), 1);
assert_eq!(pagina.total, 3);
assert_eq!((pagina.limite, pagina.desplazamiento), (2, 2));
}
{% for u in uniques %}
#[tokio::test]
async fn deberia_rechazar_un_duplicado_de_{{ u.name }}() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let primero = nuevo_{{ snake }}();
repositorio.guardar(&primero).await.unwrap();
let mut segundo = nuevo_{{ snake }}();
segundo.{{ u.name }} = primero.{{ u.name }}{% if u.needs_clone %}.clone(){% endif %};
// Actuar
let resultado = repositorio.guardar(&segundo).await;
// Comprobar
assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
}
{% endfor %}{% for g in unique_groups %}
#[tokio::test]
async fn deberia_rechazar_un_duplicado_de_{{ g.suffix }}() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let primero = nuevo_{{ snake }}();
repositorio.guardar(&primero).await.unwrap();
let mut segundo = nuevo_{{ snake }}();
{% for f in g.fields %} segundo.{{ f.name }} = primero.{{ f.name }}{% if f.needs_clone %}.clone(){% endif %};
{% endfor %}
// Actuar
let resultado = repositorio.guardar(&segundo).await;
// Comprobar
assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
}
#[tokio::test]
async fn deberia_aceptar_{{ g.suffix }}_cuando_solo_coincide_{{ g.first }}() {
// Preparar
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let primero = nuevo_{{ snake }}();
repositorio.guardar(&primero).await.unwrap();
let mut segundo = nuevo_{{ snake }}();
segundo.{{ g.fields.0.name }} = primero.{{ g.fields.0.name }}{% if g.fields.0.needs_clone %}.clone(){% endif %};
// Actuar
let resultado = repositorio.guardar(&segundo).await;
// Comprobar
assert!(resultado.is_ok());
}
{% endfor %}{% for r in refs %}
#[tokio::test]
async fn deberia_listar_solo_{{ plural }}_con_ese_valor_de_{{ r.name }}() {
// Preparar: una entidad {{ snake }} con este valor de {{ r.name }} y otra sin él.
let repositorio = Repositorio{{ pascal }}EnMemoria::new();
let {{ r.name }} = Id{{ r.ref_target }}::generar();
let mut esperado = nuevo_{{ snake }}();
esperado.{{ r.name }} = {% if r.field_type is starting_with("Option<") %}Some({{ r.name }}){% else %}{{ r.name }}{% endif %};
repositorio.guardar(&esperado).await.unwrap();
repositorio.guardar(&nuevo_{{ snake }}()).await.unwrap();
// Actuar
let pagina = repositorio
.buscar_todos(
PeticionPagina::default(),
Filtro{{ pascal }} {
{% for o in refs %} {{ o.name }}: {% if o.name == r.name %}Some({{ r.name }}){% else %}None{% endif %},
{% endfor %} },
)
.await
.unwrap();
// Comprobar
assert_eq!(pagina.elementos.iter().map(|fila| fila.id).collect::<Vec<_>>(), vec![esperado.id]);
assert_eq!(pagina.total, 1);
}
{% endfor %}}