//! `{{ name }}`: reacciona a {% for e in events %}`{{ e.event_type }}`{% if not loop.last %}, {% endif %}{% endfor %}. Lo escribe una vez
//! `puerto generar consumidor`; desde entonces es tuyo.
//!
//! La entrega es al menos una vez: el mismo evento (el mismo `evento.id`) puede llegar dos veces,
//! tras una caída, un timeout o un redespliegue. Lo que haga esto debe ser **idempotente**:
//! comprueba si ya ocurrió (por `evento.id`) antes de volver a hacerlo.
//!
//! `Ack` cuando termina; `Reintentar` para un fallo que puede pasar (el worker vuelve a entregarlo
//! con una espera creciente y después lo descarta); `ResultadoManejo::descartar(…)` para uno que no
//! pasará nunca.
use async_trait::async_trait;
{% for import in imports -%}
use {{ import }};
{% endfor -%}
use puerto_nucleo::eventos::{SobreEvento, ManejadorEvento, ResultadoManejo, MOTIVO_PAYLOAD_INVALIDO};
use sqlx::PgPool;
pub struct {{ pascal }};
impl {{ pascal }} {
/// Lo llama `generado/registro.rs` al arrancar el worker, con su pool. Lo que necesite el
/// consumidor se construye aquí y se guarda en sus campos: `cableado::<contexto>::construir(pool)`
/// da los casos de uso de un contexto (con `cableado` en el `Cargo.toml` del worker).
pub fn construir(_pool: &PgPool) -> Self {
Self
}
}
#[async_trait]
impl ManejadorEvento for {{ pascal }} {
async fn manejar(&self, evento: &SobreEvento) -> ResultadoManejo {
match evento.tipo_evento.as_str() {
{%- for e in events %}
{{ e.constant }} => match evento.decodificar::<Snapshot{{ e.entity_pascal }}>() {
Ok({{ e.entity_snake }}) => {
tracing::info!(
id_evento = %evento.id,
id_{{ e.entity_snake }} = %{{ e.entity_snake }}.id,
"{{ name }}: {{ e.event_type }}"
);
ResultadoManejo::Ack
}
Err(err) => ResultadoManejo::descartar(MOTIVO_PAYLOAD_INVALIDO, err.detalle),
},
{%- endfor %}
// Sin suscripción (puerto.toml `[[consumidor]] eventos`): nada que hacer.
_ => ResultadoManejo::Ack,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use dominio_{{ first.entity_snake }}::eventos::Evento{{ first.entity_pascal }};
use dominio_{{ first.entity_snake }}::pruebas::madres::Madre{{ first.entity_pascal }};
fn {{ first.const_lower }}() -> SobreEvento {
let snapshot = Snapshot{{ first.entity_pascal }}::from_entidad(&Madre{{ first.entity_pascal }}::aleatorio());
SobreEvento::new(&Evento{{ first.entity_pascal }}::{{ first.variant }}(snapshot))
}
#[tokio::test]
async fn deberia_hacer_ack_cuando_el_evento_{{ first.event_type }}_es_valido() {
// Preparar
let evento = {{ first.const_lower }}();
// Actuar
let resultado = {{ pascal }}.manejar(&evento).await;
// Comprobar
assert_eq!(resultado, ResultadoManejo::Ack);
}
#[tokio::test]
async fn deberia_hacer_ack_otra_vez_cuando_el_mismo_evento_llega_dos_veces() {
// Preparar
let evento = {{ first.const_lower }}();
// Actuar
let primero = {{ pascal }}.manejar(&evento).await;
let segundo = {{ pascal }}.manejar(&evento).await;
// Comprobar
assert_eq!((primero, segundo), (ResultadoManejo::Ack, ResultadoManejo::Ack));
}
#[tokio::test]
async fn deberia_descartar_cuando_el_payload_esta_mal_formado() {
// Preparar
let mut evento = {{ first.const_lower }}();
evento.payload = serde_json::json!({ "unexpected": true });
// Actuar
let resultado = {{ pascal }}.manejar(&evento).await;
// Comprobar
assert!(
matches!(
resultado,
ResultadoManejo::Descartar {
motivo: MOTIVO_PAYLOAD_INVALIDO,
..
}
),
"{resultado:?}"
);
}
}