puerto 0.23.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.
//! Renderiza el correo `{{ name }}` con sus plantillas y se lo pasa al enviador. Lo escribe una
//! vez `puerto generar correo`; desde entonces es tuyo. El texto está en `plantillas/{{ name }}/`:
//! cámbialo allí; los tests de abajo lo vuelven a renderizar, así que una errata hace fallar
//! `make test`.

use std::sync::Arc;

use async_trait::async_trait;
use dominio_correo::{{ name }}::{ {{- "Correo" ~ pascal }}, EnviadorCorreo{{ pascal }}};
use puerto_correo::{ErrorCorreo, EnviadorCorreo, Plantillas};
use serde::Serialize;
{%- for import in imports %}
use {{ import }};
{%- endfor %}

const PLANTILLAS: Plantillas = Plantillas::new(
    include_str!("../plantillas/{{ name }}/asunto.txt"),
    include_str!("../plantillas/{{ name }}/cuerpo.html"),
)
.con_texto(include_str!("../plantillas/{{ name }}/cuerpo.txt"));

/// Lo que ven las plantillas: los campos del correo salvo el destinatario, con sus propios nombres.
#[derive(Serialize)]
struct Contexto<'a> {
{%- for f in fields %}
    {{ f.name }}: &'a {{ f.rust_type }},
{%- endfor %}
}

impl<'a> Contexto<'a> {
    fn de(correo: &'a Correo{{ pascal }}) -> Self {
        Self {
{%- for f in fields %}
            {{ f.name }}: &correo.{{ f.name }},
{%- endfor %}
        }
    }
}

/// El correo `{{ name }}`, renderizado desde `plantillas/{{ name }}/` y enviado por `enviador`
/// (`puerto_correo::EnviadorCorreoSmtp` allí donde se ejecuta).
pub struct EnviadorCorreo{{ pascal }}Plantilla {
    enviador: Arc<dyn EnviadorCorreo>,
}

impl EnviadorCorreo{{ pascal }}Plantilla {
    pub fn new(enviador: Arc<dyn EnviadorCorreo>) -> Self {
        Self { enviador }
    }
}

#[async_trait]
impl EnviadorCorreo{{ pascal }} for EnviadorCorreo{{ pascal }}Plantilla {
    async fn enviar(&self, correo: &Correo{{ pascal }}) -> Result<(), ErrorCorreo> {
        let renderizado = PLANTILLAS.renderizar(correo.para.clone(), Contexto::de(correo))?;
        self.enviador.enviar(&renderizado).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use puerto_correo::pruebas::EnviadorCorreoGrabador;

    fn {{ name }}() -> Correo{{ pascal }} {
        Correo{{ pascal }} {
            para: "ada@example.com".to_string(),
{%- for f in fields %}
            {{ f.name }}: {{ f.sample }},
{%- endfor %}
        }
    }

    #[test]
    fn deberia_renderizar_todas_las_plantillas_cuando_el_correo_tiene_sus_campos() {
        // Actuar
        let renderizado = PLANTILLAS.renderizar("ada@example.com", Contexto::de(&{{ name }}()));

        // Comprobar
        let renderizado = match renderizado {
            Ok(renderizado) => renderizado,
            Err(err) => panic!("plantillas/{{ name }}/ no se renderiza: {err}"),
        };
        assert!(!renderizado.asunto.is_empty());
        assert!(!renderizado.html.is_empty());
        assert!(renderizado.texto.is_some());
    }

    #[tokio::test]
    async fn deberia_enviar_el_correo_renderizado_a_su_destinatario() {
        // Preparar
        let grabador = Arc::new(EnviadorCorreoGrabador::new());
        let enviador = EnviadorCorreo{{ pascal }}Plantilla::new(grabador.clone());

        // Actuar
        let resultado = enviador.enviar(&{{ name }}()).await;

        // Comprobar
        assert_eq!(resultado, Ok(()));
        let enviados = grabador.enviados();
        assert_eq!(enviados.len(), 1);
        assert_eq!(enviados[0].para, "ada@example.com");
    }

    #[tokio::test]
    async fn deberia_devolver_el_error_del_enviador_cuando_el_envio_falla() {
        // Preparar
        let rechazado = ErrorCorreo::Permanente("550 no such user".to_string());
        let enviador =
            EnviadorCorreo{{ pascal }}Plantilla::new(Arc::new(EnviadorCorreoGrabador::fallando_con(rechazado.clone())));

        // Actuar
        let resultado = enviador.enviar(&{{ name }}()).await;

        // Comprobar
        assert_eq!(resultado, Err(rechazado));
    }
}