{% 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;
use dominio_{{ snake }}::{
errores::Error{{ pascal }},
modelo::{{ pascal }},
repositorio::Repositorio{{ pascal }},
};
pub struct Obtener{{ pascal }}Impl {
pub repositorio: Arc<dyn Repositorio{{ pascal }}>,
}
#[async_trait]
impl Obtener{{ pascal }} for Obtener{{ pascal }}Impl {
async fn ejecutar(&self, params: ParamsObtener{{ pascal }}) -> Result<{{ pascal }}, Error{{ pascal }}> {
tracing::info!(id = %params.id, "obtener_{{ snake }}: inicio");
let resultado = self.repositorio.buscar_por_id(params.id).await.inspect_err(|e| tracing::error!(error = %e, "obtener_{{ snake }}: fallo del repositorio"))?;
resultado.ok_or_else(|| {
let err = Error{{ pascal }}::NoEncontrado;
tracing::warn!(error = %err, "obtener_{{ snake }}: rechazado");
err
})
}
}
#[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 }},
};
use puerto_nucleo::ErrorRepositorio;
{% for import in test_imports %} use {{ import }};
{% endfor %}
#[tokio::test]
async fn deberia_devolver_{{ snake }}_cuando_el_id_existe() {
let entidad = {{ pascal }}::new(Props{{ pascal }} {
{{ macros::props(fields=fields, word="example") }} }).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 = Obtener{{ pascal }}Impl {
repositorio: Arc::new(repositorio_doble),
};
let resultado = caso_de_uso.ejecutar(ParamsObtener{{ pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}id: id_entidad }).await;
assert!(resultado.is_ok());{% if required %}
assert_eq!(resultado.unwrap().{{ required.0.name }}, "example");{% elif string_vos %}
assert_eq!(resultado.unwrap().{{ string_vos.0.name }}.valor(), "example");{% endif %}
}
#[tokio::test]
async fn deberia_devolver_no_encontrado_cuando_el_id_no_existe() {
let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
repositorio_doble.expect_buscar_por_id().returning(|_| Ok(None));
let caso_de_uso = Obtener{{ pascal }}Impl {
repositorio: Arc::new(repositorio_doble),
};
let resultado = caso_de_uso
.ejecutar(ParamsObtener{{ pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}id: Id{{ pascal }}::generar() })
.await;
assert!(resultado.is_err());
assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.no_encontrado");
}
#[tokio::test]
async fn deberia_devolver_error_de_repositorio_cuando_el_almacen_no_esta_disponible() {
let mut repositorio_doble = MockRepositorio{{ pascal }}::new();
repositorio_doble
.expect_buscar_por_id()
.returning(|_| Err(ErrorRepositorio::NoDisponible));
let caso_de_uso = Obtener{{ pascal }}Impl {
repositorio: Arc::new(repositorio_doble),
};
let resultado = caso_de_uso
.ejecutar(ParamsObtener{{ pascal }} { {% if actor %}actor: MadrePrincipal::aleatorio(), {% endif %}id: Id{{ pascal }}::generar() })
.await;
assert!(resultado.is_err());
assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.repositorio");
}
}