puerto 0.21.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.
{% import "application/macros.tera" as macros %}{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}use std::sync::Arc;

use async_trait::async_trait;
{% for import in vo_imports %}use {{ import }};
{% endfor %}
use dominio_{{ snake }}::{
    errores::Error{{ pascal }},
    modelo::{{ pascal }},
    repositorio::Repositorio{{ pascal }},
};

pub struct Actualizar{{ pascal }}Impl {
    pub repositorio: Arc<dyn Repositorio{{ pascal }}>,
}

#[async_trait]
impl Actualizar{{ pascal }} for Actualizar{{ pascal }}Impl {
    async fn ejecutar(&self, params: ParamsActualizar{{ pascal }}) -> Result<{{ pascal }}, Error{{ pascal }}> {
        tracing::info!(id = %params.id, "actualizar_{{ snake }}: inicio");
        let mut entidad = self
            .repositorio
            .buscar_por_id(params.id)
            .await
            .inspect_err(|e| tracing::error!(error = %e, "actualizar_{{ snake }}: fallo del repositorio"))?
            .ok_or_else(|| {
                let err = Error{{ pascal }}::NoEncontrado;
                tracing::warn!(error = %err, "actualizar_{{ snake }}: rechazado");
                err
            })?;
{% for f in required %}        if params.{{ f.name }}.trim().is_empty() {
            let err = Error{{ pascal }}::Validacion("{{ f.name }}_vacio".into());
            tracing::warn!(error = %err, "actualizar_{{ snake }}: rechazado");
            return Err(err);
        }
{% endfor %}{% for f in fields | filter(attribute="is_vo", value=true) %}let {{ f.name }}{% if f.is_vec_vo %}: Vec<{{ f.vo }}>{% endif %} = {{ f.from_params }};
{% endfor %}{% for f in fields %}        entidad.{{ f.name }} = {% if not f.is_vo %}params.{% endif %}{{ f.name }};
{% endfor %}        entidad.actualizado_en = chrono::Utc::now();
        self.repositorio.guardar(&entidad).await.inspect_err(|e| tracing::error!(error = %e, "actualizar_{{ snake }}: fallo del repositorio"))?;
        Ok(entidad)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
{% if actor %}    use puerto_nucleo::auth::dobles::MadrePrincipal;
{% endif %}    use dominio_{{ snake }}::{
        modelo::{{ "{" }}{{ pascal }}, Id{{ pascal }}, Props{{ pascal }}},
        repositorio::dobles::MockRepositorio{{ pascal }},
    };
{% for import in test_imports %}    use {{ import }};
{% endfor %}

    #[tokio::test]
    async fn deberia_actualizar_{{ snake }}_cuando_los_parametros_son_validos() {
        // Preparar
        let entidad = {{ pascal }}::new(Props{{ pascal }} {
{{ macros::props(fields=fields, word="original") }}        }).unwrap();
        let id_entidad = entidad.id;
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_por_id()
            .returning(move |_| Ok(Some(entidad.clone())));
        repositorio_doble.expect_guardar().returning(|_| Ok(()));
        let caso_de_uso = Actualizar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsActualizar{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}            id: id_entidad,
{{ macros::params(fields=fields, word="updated") }}            })
            .await;

        // Comprobar
        {% if required %}assert_eq!(resultado.unwrap().{{ required.0.name }}, "updated");{% elif string_vos %}assert_eq!(resultado.unwrap().{{ string_vos.0.name }}.valor(), "updated");{% else %}assert!(resultado.is_ok());{% endif %}
    }

    #[tokio::test]
    async fn deberia_devolver_no_encontrado_cuando_{{ snake }}_no_existe() {
        // Preparar
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble.expect_buscar_por_id().returning(|_| Ok(None));
        let caso_de_uso = Actualizar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsActualizar{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}            id: Id{{ pascal }}::generar(),
{{ macros::params(fields=fields, word="new") }}            })
            .await;

        // Comprobar
        assert!(resultado.is_err());
        assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.no_encontrado");
    }
{% for f in required | concat(with=string_vos) %}
    #[tokio::test]
    async fn deberia_devolver_error_cuando_{{ f.name }}_es_una_cadena_vacia() {
        // Preparar
        let entidad = {{ pascal }}::new(Props{{ pascal }} {
{{ macros::props(fields=fields, word="original") }}        }).unwrap();
        let id_entidad = entidad.id;
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_por_id()
            .returning(move |_| Ok(Some(entidad.clone())));
        let caso_de_uso = Actualizar{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsActualizar{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}            id: id_entidad,
{{ macros::params(fields=fields, word="updated", empty=f.name) }}            })
            .await;

        // Comprobar
        assert!(resultado.is_err());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{% if f.is_vo %}{{ snake }}.{{ f.vo_snake }}_invalido{% else %}{{ snake }}.validacion.{{ f.name }}_vacio{% endif %}"
        );
    }
{% endfor %}}