{% 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 puerto_nucleo::ErrorRepositorio;
{% for import in vo_imports %}use {{ import }};
{% endfor %}
use dominio_{{ snake }}::{
errores::Error{{ pascal }},
eventos::{{ "{" }}Evento{{ pascal }}, Snapshot{{ pascal }}},
modelo::{{ "{" }}{{ pascal }}, Props{{ pascal }}},
unit_of_work::UnitOfWorkFactory{{ pascal }},
};
pub struct Crear{{ pascal }}Impl {
pub uow_factory: Arc<dyn UnitOfWorkFactory{{ 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");
let fallido = |e: &ErrorRepositorio| tracing::error!(error = %e, "crear_{{ snake }}: fallo del repositorio");
{% 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"))?;
let mut uow = self.uow_factory.begin().await.inspect_err(fallido)?;
uow.guardar(&entidad).await.inspect_err(fallido)?;
uow.registrar(Evento{{ pascal }}::Creado(Snapshot{{ pascal }}::from_entidad(&entidad))).await.inspect_err(fallido)?;
uow.commit().await.inspect_err(fallido)?;
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 }}::unit_of_work::dobles::{FallarEn, UnitOfWorkFactoryGrabadora};
use puerto_nucleo::EventoDominio;
{% for import in test_imports %} use {{ import }};
{% endfor %}
#[tokio::test]
async fn deberia_registrar_el_evento_{{ snake }}_creado_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 uow_factory = UnitOfWorkFactoryGrabadora::new();
let caso_de_uso = Crear{{ pascal }}Impl {
uow_factory: Arc::new(uow_factory.clone()),
};
// Actuar
let resultado = caso_de_uso
.ejecutar(ParamsCrear{{ pascal }} {
{% if actor %} actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params(fields=fields, word="example") }} })
.await;
// Comprobar
let entidad = match resultado {
Ok(entidad) => entidad,
Err(e) => panic!("la creación falló: {e}"),
};{% set enum_vos = fields | filter(attribute="is_enum_vo", value=true) %}{% if required %}
assert_eq!(entidad.{{ required.0.name }}, "example");{% elif string_vos %}
assert_eq!(entidad.{{ string_vos.0.name }}.valor(), "example");{% elif enum_vos %}
assert_eq!(entidad.{{ enum_vos.0.name }}.as_str(), "{{ enum_vos.0.first_variant }}");{% endif %}
let grabado = uow_factory.grabado();
assert!(grabado.confirmado);
assert_eq!(grabado.guardados.len(), 1);
assert_eq!(grabado.eventos.len(), 1);
assert_eq!(grabado.eventos[0].tipo_evento(), "{{ snake }}_creado");
assert_eq!(grabado.eventos[0].id_agregado(), entidad.id.valor());
}
#[tokio::test]
async fn no_deberia_hacer_commit_cuando_el_almacen_rechaza_un_duplicado() {
// Preparar
let uow_factory = UnitOfWorkFactoryGrabadora::fallando_en(FallarEn::Guardar, ErrorRepositorio::Duplicado);
let caso_de_uso = Crear{{ pascal }}Impl {
uow_factory: Arc::new(uow_factory.clone()),
};
// Actuar
let resultado = caso_de_uso
.ejecutar(ParamsCrear{{ pascal }} {
{% if actor %} actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params(fields=fields, word="example") }} })
.await;
// Comprobar
assert!(resultado.is_err());
assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.duplicado");
let grabado = uow_factory.grabado();
assert!(!grabado.confirmado);
assert!(grabado.eventos.is_empty());
}
{% 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 uow_factory = UnitOfWorkFactoryGrabadora::fallando_en(
FallarEn::Guardar,
ErrorRepositorio::ReferenciaInexistente("{{ r.name }}"),
);
let caso_de_uso = Crear{{ pascal }}Impl {
uow_factory: Arc::new(uow_factory.clone()),
};
// Actuar
let resultado = caso_de_uso
.ejecutar(ParamsCrear{{ pascal }} {
{% if actor %} actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params(fields=fields, word="example") }} })
.await;
// Comprobar
assert!(resultado.is_err());
assert_eq!(
resultado.unwrap_err().to_string(),
"{{ snake }}.validacion.{{ r.name }}_no_encontrado"
);
assert!(!uow_factory.grabado().confirmado);
}
{% endfor %}
#[tokio::test]
async fn deberia_devolver_error_de_repositorio_cuando_falla_el_commit() {
// Preparar
let uow_factory = UnitOfWorkFactoryGrabadora::fallando_en(FallarEn::Commit, ErrorRepositorio::NoDisponible);
let caso_de_uso = Crear{{ pascal }}Impl {
uow_factory: Arc::new(uow_factory.clone()),
};
// Actuar
let resultado = caso_de_uso
.ejecutar(ParamsCrear{{ pascal }} {
{% if actor %} actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params(fields=fields, word="example") }} })
.await;
// Comprobar
assert!(resultado.is_err());
assert_eq!(resultado.unwrap_err().to_string(), "{{ snake }}.repositorio");
assert!(!uow_factory.grabado().confirmado);
}
{% 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_sin_registrar_nada_cuando_{{ f.name }}_es_una_cadena_vacia() {
// Preparar
let uow_factory = UnitOfWorkFactoryGrabadora::new();
let caso_de_uso = Crear{{ pascal }}Impl {
uow_factory: Arc::new(uow_factory.clone()),
};
// Actuar
let resultado = caso_de_uso
.ejecutar(ParamsCrear{{ pascal }} {
{% if actor %} actor: MadrePrincipal::aleatorio(),
{% endif %}{{ macros::params(fields=fields, word="example", 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 %}"
);
assert!(uow_factory.grabado().guardados.is_empty());
}
{% endfor %}}