{% 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 %}}