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.
{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}{% set refs = fields | filter(attribute="is_ref", value=true) %}use std::sync::Arc;

use async_trait::async_trait;
use puerto_nucleo::Pagina;

use dominio_{{ snake }}::{
    errores::Error{{ pascal }},
    modelo::{{ pascal }},
    repositorio::{% if refs %}{{ "{" }}Filtro{{ pascal }}, Repositorio{{ pascal }}}{% else %}Repositorio{{ pascal }}{% endif %},
};

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

#[async_trait]
impl Listar{{ plural_pascal }} for Listar{{ plural_pascal }}Impl {
    async fn ejecutar(&self, params: ParamsListar{{ plural_pascal }}) -> Result<Pagina<{{ pascal }}>, Error{{ pascal }}> {
        tracing::info!(limite = params.pagina.limite(), desplazamiento = params.pagina.desplazamiento(), "listar_{{ plural }}: inicio");
        self.repositorio
{% if refs %}            .buscar_todos(
                params.pagina,
                Filtro{{ pascal }} {
{% for r in refs %}                    {{ r.name }}: params.{{ r.name }},
{% endfor %}                },
            )
{% else %}            .buscar_todos(params.pagina)
{% endif %}            .await
            .inspect_err(|e| tracing::error!(error = %e, "listar_{{ plural }}: fallo del repositorio"))
            .map_err(Error{{ pascal }}::from)
    }
}

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

    #[tokio::test]
    async fn deberia_devolver_la_pagina_de_{{ plural }}() {
        let entidades = Madre{{ pascal }}::aleatorios(2);
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_todos()
            .returning(move |pagina{% if refs %}, _{% endif %}| Ok(Pagina::new(entidades.clone(), 2, pagina)));
        let caso_de_uso = Listar{{ plural_pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsListar{{ plural_pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}pagina: PeticionPagina::default(){% for r in refs %}, {{ r.name }}: None{% endfor %} })
            .await;

        let pagina = resultado.unwrap();
        assert_eq!(pagina.elementos.len(), 2);
        assert_eq!(pagina.total, 2);
    }

    #[tokio::test]
    async fn deberia_devolver_una_pagina_vacia_cuando_no_hay_{{ plural }}() {
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_todos()
            .returning(|pagina{% if refs %}, _{% endif %}| Ok(Pagina::new(vec![], 0, pagina)));
        let caso_de_uso = Listar{{ plural_pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsListar{{ plural_pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}pagina: PeticionPagina::default(){% for r in refs %}, {{ r.name }}: None{% endfor %} })
            .await;

        let pagina = resultado.unwrap();
        assert!(pagina.elementos.is_empty());
        assert_eq!(pagina.total, 0);
    }

    #[tokio::test]
    async fn deberia_pasar_al_repositorio_la_pagina_pedida() {
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_todos()
            .withf(|pagina{% if refs %}, _{% endif %}| pagina.limite() == 5 && pagina.desplazamiento() == 10)
            .returning(|pagina{% if refs %}, _{% endif %}| Ok(Pagina::new(vec![], 0, pagina)));
        let caso_de_uso = Listar{{ plural_pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsListar{{ plural_pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}pagina: PeticionPagina::new(Some(5), Some(10)){% for r in refs %}, {{ r.name }}: None{% endfor %} })
            .await;

        assert_eq!(resultado.unwrap().desplazamiento, 10);
    }
{% if refs %}
    #[tokio::test]
    async fn deberia_pasar_el_filtro_al_repositorio() {
        let filtro = Filtro{{ pascal }} {
{% for r in refs %}            {{ r.name }}: Some(Id{{ r.ref_target }}::generar()),
{% endfor %}        };
        let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
        repositorio_doble
            .expect_buscar_todos()
            .withf(move |_, f| *f == filtro)
            .returning(|pagina, _| Ok(Pagina::new(vec![], 0, pagina)));
        let caso_de_uso = Listar{{ plural_pascal }}Impl {
            repositorio: Arc::new(repositorio_doble),
        };

        let resultado = caso_de_uso
            .ejecutar(ParamsListar{{ plural_pascal }} {
{% if actor %}                actor: MadrePrincipal::aleatorio(),
{% endif %}                pagina: PeticionPagina::default(),
{% for r in refs %}                {{ r.name }}: filtro.{{ r.name }},
{% endfor %}            })
            .await;

        assert!(resultado.is_ok());
    }
{% endif %}}