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.
{% 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 }}, Props{{ pascal }}},
    repositorio::Repositorio{{ pascal }},
};

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

#[async_trait]
impl Crear{{ pascal }} for Crear{{ pascal }}Impl {
    async fn ejecutar(&self, params: ParamsCrear{{ pascal }}) -> Result<{{ pascal }}, Error{{ pascal }}> {
        tracing::info!("crear_{{ snake }}: inicio");
{% 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 %}        let entidad = {{ pascal }}::new(Props{{ pascal }} {
{% for f in fields %}            {{ f.name }}{% if not f.is_vo %}: params.{{ f.name }}{% endif %},
{% endfor %}        }).inspect_err(|e| tracing::warn!(error = %e, "crear_{{ snake }}: rechazado"))?;
        self.repositorio.guardar(&entidad).await.inspect_err(|e| tracing::error!(error = %e, "crear_{{ snake }}: fallo del repositorio"))?;
        tracing::info!(id = %entidad.id, "crear_{{ snake }}: fin");
        Ok(entidad)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
{% if actor %}    use puerto_nucleo::auth::dobles::MadrePrincipal;
{% endif %}    use dominio_{{ snake }}::repositorio::dobles::MockRepositorio{{ pascal }};
    use puerto_nucleo::ErrorRepositorio;
    use dominio_{{ snake }}::pruebas::madres::Madre{{ pascal }};


    #[tokio::test]
    async fn deberia_crear_{{ snake }}_cuando_{% if fields | length == 1 and required | length == 1 and fields.0.name == "nombre" %}el_nombre_es_valido{% else %}los_campos_son_validos{% endif %}() {
        // Preparar
        let props = Madre{{ pascal }}::new().construir_props();
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble.expect_guardar().returning(|_| Ok(()));
        let caso_de_uso = Crear{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsCrear{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params_madre(fields=fields) }}            })
            .await;

        // Comprobar
        assert!(resultado.is_ok());{% set enum_vos = fields | filter(attribute="is_enum_vo", value=true) %}{% set checked = required | concat(with=string_vos) | concat(with=enum_vos) %}{% if checked %}
        assert_eq!(resultado.unwrap().{{ checked.0.name }}, Madre{{ pascal }}::new().construir_props().{{ checked.0.name }});{% endif %}
    }

    #[tokio::test]
    async fn deberia_devolver_duplicado_cuando_el_almacen_rechaza_un_duplicado() {
        // Preparar
        let props = Madre{{ pascal }}::new().construir_props();
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_guardar()
            .returning(|_| Err(ErrorRepositorio::Duplicado));
        let caso_de_uso = Crear{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsCrear{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params_madre(fields=fields) }}            })
            .await;

        // Comprobar
        assert!(resultado.is_err());
        assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.duplicado");
    }
{% for r in fields | filter(attribute="is_ref", value=true) %}
    #[tokio::test]
    async fn deberia_devolver_un_error_de_validacion_cuando_{{ r.name }}_no_existe() {
        // Preparar: en el almacén no hay {{ r.ref_target }} con ese id.
        let props = Madre{{ pascal }}::new().construir_props();
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_guardar()
            .returning(|_| Err(ErrorRepositorio::ReferenciaInexistente("{{ r.name }}")));
        let caso_de_uso = Crear{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsCrear{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params_madre(fields=fields) }}            })
            .await;

        // Comprobar
        assert!(resultado.is_err());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{{ snake }}.validacion.{{ r.name }}_no_encontrado"
        );
    }
{% endfor %}{% for f in required | concat(with=fields | filter(attribute="is_vo", value=true) | filter(attribute="field_type", value="String")) %}
    #[tokio::test]
    async fn deberia_devolver_error_cuando_{{ f.name }}_es_una_cadena_vacia() {
        // Preparar
{% if fields | length > 1 %}        let props = Madre{{ pascal }}::new().construir_props();
{% endif %}        let repositorio_doble = MockRepositorio{{ pascal }}::new();
        let caso_de_uso = Crear{{ pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        // Actuar
        let resultado = caso_de_uso
            .ejecutar(ParamsCrear{{ pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params_madre(fields=fields, 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 %}}