//! `correo_{{ name }}`: envía el correo `{{ name }}` tras {% for e in events %}`{{ e.event_type }}`{% if not loop.last %}, {% endif %}{% endfor %}. Lo escribe una vez
//! `puerto generar correo --tras`; desde entonces es tuyo: cambia a quién va, sáltate algunos
//! eventos, añade valores que el snapshot no lleva.
//!
//! La entrega es al menos una vez: `enviar_una_vez` guarda una fila en `correos_enviados` por
//! evento, así que un evento que se vuelve a entregar no envía el correo otra vez. Deja `CORREO`
//! como está: renombrarlo vuelve a enviar todos los correos.
use std::sync::Arc;
use async_trait::async_trait;
use dominio_correo::{{ name }}::{ {{- "Correo" ~ pascal }}, EnviadorCorreo{{ pascal }}};
{%- for import in imports %}
use {{ import }};
{%- endfor %}
use puerto_nucleo::eventos::{SobreEvento, ManejadorEvento, ResultadoManejo, MOTIVO_PAYLOAD_INVALIDO};
use puerto_nucleo::correo::CorreosEnviados;
use puerto_correo::enviar_una_vez;
/// La clave de este correo en `correos_enviados`.
const CORREO: &str = "{{ name }}";
pub struct EnviarCorreo{{ pascal }} {
pub enviador: Arc<dyn EnviadorCorreo{{ pascal }}>,
pub correos_enviados: Arc<dyn CorreosEnviados>,
}
#[async_trait]
impl ManejadorEvento for EnviarCorreo{{ pascal }} {
async fn manejar(&self, evento: &SobreEvento) -> ResultadoManejo {
let correo = match evento.tipo_evento.as_str() {
{%- for e in events %}
{{ e.constant }} => match evento.decodificar::<Snapshot{{ e.entity_pascal }}>() {
Ok({{ e.entity_snake }}) => Correo{{ pascal }} {
para: {{ e.entity_snake }}.{{ to }}.clone(),
{%- for f in fields %}
{{ f.name }}: {{ e.entity_snake }}.{{ f.name }},
{%- endfor %}
},
Err(err) => return ResultadoManejo::descartar(MOTIVO_PAYLOAD_INVALIDO, err.detalle),
},
{%- endfor %}
// No es uno de sus eventos (puerto.toml `[[correo]] tras`): nada que enviar.
_ => return ResultadoManejo::Ack,
};
if correo.para.trim().is_empty() {
tracing::warn!(id_evento = %evento.id, "correo_{{ name }}: sin destinatario, no se envía");
return ResultadoManejo::Ack;
}
enviar_una_vez(self.correos_enviados.as_ref(), evento.id, CORREO, self.enviador.enviar(&correo)).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use dominio_correo::{{ name }}::dobles::MockEnviadorCorreo{{ pascal }};
use dominio_{{ first.entity_snake }}::eventos::Evento{{ first.entity_pascal }};
use dominio_{{ first.entity_snake }}::pruebas::madres::Madre{{ first.entity_pascal }};
use puerto_nucleo::eventos::MOTIVO_ERROR_PERMANENTE;
use puerto_nucleo::correo::ErrorCorreo;
use puerto_correo::pruebas::CorreosEnviadosEnMemoria;
fn {{ first.const_lower }}() -> (Snapshot{{ first.entity_pascal }}, SobreEvento) {
let snapshot = Snapshot{{ first.entity_pascal }}::from_entidad(&Madre{{ first.entity_pascal }}::aleatorio());
let evento = SobreEvento::new(&Evento{{ first.entity_pascal }}::{{ first.variant }}(snapshot.clone()));
(snapshot, evento)
}
/// Un enviador que espera enviar `times` correos, y cada uno responde `resultado`.
fn enviador(times: usize, resultado: Result<(), ErrorCorreo>) -> MockEnviadorCorreo{{ pascal }} {
let mut enviador = MockEnviadorCorreo{{ pascal }}::new();
enviador
.expect_enviar()
.times(times)
.returning(move |_| resultado.clone());
enviador
}
fn manejador(enviador: MockEnviadorCorreo{{ pascal }}) -> EnviarCorreo{{ pascal }} {
EnviarCorreo{{ pascal }} {
enviador: Arc::new(enviador),
correos_enviados: Arc::new(CorreosEnviadosEnMemoria::new()),
}
}
#[tokio::test]
async fn deberia_enviar_el_correo_a_{{ to }}_cuando_llega_un_evento_{{ first.event_type }}() {
// Preparar
let (snapshot, evento) = {{ first.const_lower }}();
let mut doble = MockEnviadorCorreo{{ pascal }}::new();
doble.expect_enviar()
.withf(move |correo| correo.para == snapshot.{{ to }})
.times(1)
.returning(|_| Ok(()));
// Actuar
let resultado = manejador(doble).manejar(&evento).await;
// Comprobar
assert_eq!(resultado, ResultadoManejo::Ack);
}
#[tokio::test]
async fn deberia_enviarlo_una_vez_cuando_el_mismo_evento_llega_dos_veces() {
// Preparar
let (_, evento) = {{ first.const_lower }}();
let manejador = manejador(enviador(1, Ok(())));
// Actuar
let primero = manejador.manejar(&evento).await;
let segundo = manejador.manejar(&evento).await;
// Comprobar
assert_eq!((primero, segundo), (ResultadoManejo::Ack, ResultadoManejo::Ack));
}
#[tokio::test]
async fn deberia_descartar_sin_enviar_cuando_el_payload_esta_mal_formado() {
// Preparar
let (_, mut evento) = {{ first.const_lower }}();
evento.payload = serde_json::json!({ "unexpected": true });
// Actuar
let resultado = manejador(enviador(0, Ok(()))).manejar(&evento).await;
// Comprobar
assert!(
matches!(
resultado,
ResultadoManejo::Descartar {
motivo: MOTIVO_PAYLOAD_INVALIDO,
..
}
),
"{resultado:?}"
);
}
#[tokio::test]
async fn deberia_reintentar_cuando_el_servidor_de_correo_no_esta_disponible() {
// Preparar
let (_, evento) = {{ first.const_lower }}();
let rechazado = Err(ErrorCorreo::Transitorio("connection refused".to_string()));
// Actuar
let resultado = manejador(enviador(1, rechazado)).manejar(&evento).await;
// Comprobar
assert_eq!(resultado, ResultadoManejo::Reintentar);
}
#[tokio::test]
async fn deberia_descartar_cuando_el_servidor_rechaza_el_correo() {
// Preparar
let (_, evento) = {{ first.const_lower }}();
let rechazado = Err(ErrorCorreo::Permanente("550 no such user".to_string()));
// Actuar
let resultado = manejador(enviador(1, rechazado)).manejar(&evento).await;
// Comprobar
assert!(
matches!(
resultado,
ResultadoManejo::Descartar {
motivo: MOTIVO_ERROR_PERMANENTE,
..
}
),
"{resultado:?}"
);
}
}