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.
use std::collections::HashMap;
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};

use async_trait::async_trait;
use dominio_usuario::{
    modelo::{Usuario, IdUsuario},
    repositorio::RepositorioUsuario,
};
use puerto_nucleo::ErrorRepositorio;

/// Guarda los usuarios en la memoria del proceso: se pierden cuando el proceso se detiene y se dan
/// de alta de nuevo en su siguiente petición. Hace las veces de base de datos hasta que la haya
/// (`puerto nuevo --db`).
#[derive(Default)]
pub struct RepositorioUsuarioEnMemoria {
    filas: RwLock<HashMap<IdUsuario, Usuario>>,
}

impl RepositorioUsuarioEnMemoria {
    pub fn new() -> Self {
        Self::default()
    }

    // Un cerrojo envenenado significa que un escritor entró en pánico; cada escritura es una única
    // inserción, así que el mapa sigue entero y se usa tal cual.
    fn read(&self) -> RwLockReadGuard<'_, HashMap<IdUsuario, Usuario>> {
        self.filas.read().unwrap_or_else(PoisonError::into_inner)
    }

    fn write(&self) -> RwLockWriteGuard<'_, HashMap<IdUsuario, Usuario>> {
        self.filas.write().unwrap_or_else(PoisonError::into_inner)
    }
}

#[async_trait]
impl RepositorioUsuario for RepositorioUsuarioEnMemoria {
    async fn buscar_por_sujeto(
        &self,
        emisor: &str,
        sujeto: &str,
    ) -> Result<Option<Usuario>, ErrorRepositorio> {
        Ok(self
            .read()
            .values()
            .find(|usuario| usuario.emisor == emisor && usuario.sujeto == sujeto)
            .cloned())
    }

    async fn buscar_por_id(&self, id: IdUsuario) -> Result<Option<Usuario>, ErrorRepositorio> {
        Ok(self.read().get(&id).cloned())
    }

    async fn guardar(&self, usuario: &Usuario) -> Result<(), ErrorRepositorio> {
        let mut filas = self.write();
        let ocupado = filas.values().any(|otro| {
            otro.id != usuario.id && otro.emisor == usuario.emisor && otro.sujeto == usuario.sujeto
        });
        if ocupado {
            return Err(ErrorRepositorio::Duplicado);
        }
        filas.insert(usuario.id, usuario.clone());
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn ada() -> Usuario {
        Usuario::aprovisionar("issuer", "ada", Some("ada@example.com".into()), None)
    }

    #[tokio::test]
    async fn deberia_encontrar_un_usuario_guardado_cuando_se_busca_por_sujeto_o_por_id() {
        // Preparar
        let repositorio = RepositorioUsuarioEnMemoria::new();
        let usuario = ada();
        repositorio.guardar(&usuario).await.expect("guardado");

        // Actuar
        let por_sujeto = repositorio.buscar_por_sujeto("issuer", "ada").await;
        let por_id = repositorio.buscar_por_id(usuario.id).await;

        // Comprobar
        assert_eq!(por_sujeto, Ok(Some(usuario.clone())));
        assert_eq!(por_id, Ok(Some(usuario)));
    }

    #[tokio::test]
    async fn no_deberia_encontrar_a_nadie_cuando_el_sujeto_es_de_otro_emisor() {
        // Preparar
        let repositorio = RepositorioUsuarioEnMemoria::new();
        repositorio.guardar(&ada()).await.expect("guardado");

        // Actuar
        let encontrado = repositorio.buscar_por_sujeto("other-issuer", "ada").await;

        // Comprobar
        assert_eq!(encontrado, Ok(None));
    }

    #[tokio::test]
    async fn deberia_rechazar_un_segundo_usuario_cuando_el_sujeto_esta_ocupado() {
        // Preparar
        let repositorio = RepositorioUsuarioEnMemoria::new();
        repositorio.guardar(&ada()).await.expect("guardado");

        // Actuar
        let resultado = repositorio.guardar(&ada()).await;

        // Comprobar
        assert_eq!(resultado, Err(ErrorRepositorio::Duplicado));
    }
}