puerto 0.22.0

Puerto — Rust full-stack DDD framework CLI. Scaffolds Clean Architecture projects with auto-wired DI, SQLx support, and zero manual wiring. Formerly puerto-framework.
//! `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:?}"
        );
    }
}