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.
//! Lo escribe una vez `puerto nuevo --auth oidc`; desde entonces es tuyo. Quien llama con el aval
//! del proveedor se convierte en una fila `Usuario` en su primera petición (ADR-0021 § 3 de Puerto).

use std::collections::HashMap;
use std::sync::{Arc, Mutex, PoisonError};
use std::time::{Duration, Instant};

use async_trait::async_trait;
use dominio_usuario::{
    modelo::{Usuario, IdUsuario},
    repositorio::RepositorioUsuario,
};
use puerto_nucleo::auth::{ErrorAuth, Autenticador, Principal};
use puerto_nucleo::ErrorRepositorio;

/// Cuánto tiempo se recuerda el id de usuario de quien llama: mientras dura, una petición no
/// cuesta ninguna búsqueda.
pub const CACHE_TTL: Duration = Duration::from_secs(60);

/// El [`Autenticador`] del proyecto: pregunta a `inner` (el proveedor) quién llama, después busca o
/// crea su `Usuario` y entrega a las rutas un [`Principal`] con su id. Los roles siguen siendo los del
/// token.
pub struct AutenticadorAprovisionador {
    interno: Arc<dyn Autenticador>,
    usuarios: Arc<dyn RepositorioUsuario>,
    emisor: String,
    /// El id de usuario de cada sujeto visto en el último [`CACHE_TTL`].
    cache: Mutex<HashMap<String, (IdUsuario, Instant)>>,
}

impl AutenticadorAprovisionador {
    /// `emisor`: `AUTH_ISSUER` — junto con el sujeto del token, lo que identifica a un usuario.
    pub fn new(
        interno: Arc<dyn Autenticador>,
        usuarios: Arc<dyn RepositorioUsuario>,
        emisor: impl Into<String>,
    ) -> Self {
        Self {
            interno,
            usuarios,
            emisor: emisor.into(),
            cache: Mutex::new(HashMap::new()),
        }
    }

    fn en_cache(&self, sujeto: &str) -> Option<IdUsuario> {
        let cache = self.cache.lock().unwrap_or_else(PoisonError::into_inner);
        cache
            .get(sujeto)
            .filter(|(_, at)| at.elapsed() < CACHE_TTL)
            .map(|(id, _)| *id)
    }

    fn recordar(&self, sujeto: &str, id: IdUsuario) {
        let mut cache = self.cache.lock().unwrap_or_else(PoisonError::into_inner);
        cache.retain(|_, (_, at)| at.elapsed() < CACHE_TTL);
        cache.insert(sujeto.to_string(), (id, Instant::now()));
    }

    /// El usuario de quien llama, creado en su primera petición.
    async fn id_usuario(&self, principal: &Principal) -> Result<IdUsuario, ErrorRepositorio> {
        if let Some(usuario) = self
            .usuarios
            .buscar_por_sujeto(&self.emisor, &principal.sujeto)
            .await?
        {
            return Ok(usuario.id);
        }
        let usuario = Usuario::aprovisionar(
            &self.emisor,
            &principal.sujeto,
            principal.email.clone(),
            principal.nombre.clone(),
        );
        match self.usuarios.guardar(&usuario).await {
            Ok(()) => {
                tracing::info!(id = %usuario.id, "usuario dado de alta");
                Ok(usuario.id)
            }
            // Dos primeras peticiones a la vez: lo creó la otra.
            Err(ErrorRepositorio::Duplicado) => self
                .usuarios
                .buscar_por_sujeto(&self.emisor, &principal.sujeto)
                .await?
                .map(|usuario| usuario.id)
                .ok_or(ErrorRepositorio::NoDisponible),
            Err(err) => Err(err),
        }
    }
}

#[async_trait]
impl Autenticador for AutenticadorAprovisionador {
    async fn autenticar(&self, token: &str) -> Result<Principal, ErrorAuth> {
        let principal = self.interno.autenticar(token).await?;
        let id = match self.en_cache(&principal.sujeto) {
            Some(id) => id,
            None => {
                let id = self.id_usuario(&principal).await.map_err(|err| {
                    tracing::error!(error = %err, "no se pudo dar de alta a quien llama");
                    ErrorAuth::NoDisponible
                })?;
                self.recordar(&principal.sujeto, id);
                id
            }
        };
        Ok(principal.con_id_usuario(id.valor()))
    }
}

#[cfg(test)]
mod tests {
    use dominio_usuario::repositorio::dobles::MockRepositorioUsuario;
    use puerto_nucleo::auth::dobles::MockAutenticador;
    use uuid::Uuid;

    use super::*;

    const EMISOR: &str = "http://localhost:8180/realms/test";

    /// El proveedor acepta `good` como Ada y rechaza cualquier otro token como caducado.
    fn proveedor() -> Arc<dyn Autenticador> {
        let mut proveedor = MockAutenticador::new();
        proveedor.expect_autenticar().returning(|token| match token {
            "good" => Ok(Principal::new(Uuid::nil(), "ada")
                .con_email("ada@example.com")
                .con_roles(["admin"])),
            _ => Err(ErrorAuth::Expirado),
        });
        Arc::new(proveedor)
    }

    fn autenticador(usuarios: MockRepositorioUsuario) -> AutenticadorAprovisionador {
        AutenticadorAprovisionador::new(proveedor(), Arc::new(usuarios), EMISOR)
    }

    #[tokio::test]
    async fn deberia_crear_el_usuario_cuando_llama_por_primera_vez() {
        // Preparar
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios.expect_buscar_por_sujeto().returning(|_, _| Ok(None));
        usuarios
            .expect_guardar()
            .withf(|usuario| {
                usuario.emisor == EMISOR
                    && usuario.sujeto == "ada"
                    && usuario.email.as_deref() == Some("ada@example.com")
            })
            .times(1)
            .returning(|_| Ok(()));

        // Actuar
        let principal = autenticador(usuarios).autenticar("good").await;

        // Comprobar
        let principal = principal.expect("autenticado");
        assert_ne!(principal.id_usuario, Uuid::nil());
        assert_eq!(principal.roles, vec!["admin"]);
    }

    #[tokio::test]
    async fn deberia_devolver_el_id_existente_cuando_quien_llama_ya_tiene_usuario() {
        // Preparar
        let conocido = Usuario::aprovisionar(EMISOR, "ada", None, None);
        let id = conocido.id;
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios
            .expect_buscar_por_sujeto()
            .returning(move |_, _| Ok(Some(conocido.clone())));
        usuarios.expect_guardar().times(0);

        // Actuar
        let principal = autenticador(usuarios).autenticar("good").await;

        // Comprobar
        assert_eq!(principal.map(|p| p.id_usuario), Ok(id.valor()));
    }

    #[tokio::test]
    async fn no_deberia_volver_a_preguntar_al_repositorio_cuando_quien_llama_esta_en_cache() {
        // Preparar
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios.expect_buscar_por_sujeto().times(1).returning(|_, _| Ok(None));
        usuarios.expect_guardar().times(1).returning(|_| Ok(()));
        let autenticador = autenticador(usuarios);
        let primero = autenticador.autenticar("good").await.expect("primera autenticación");

        // Actuar
        let segundo = autenticador.autenticar("good").await.expect("segunda autenticación");

        // Comprobar
        assert_eq!(primero.id_usuario, segundo.id_usuario);
    }

    #[tokio::test]
    async fn deberia_usar_el_usuario_de_la_otra_peticion_cuando_ambas_lo_crean_a_la_vez() {
        // Preparar
        let ganador = Usuario::aprovisionar(EMISOR, "ada", None, None);
        let id = ganador.id;
        let mut usuarios = MockRepositorioUsuario::new();
        let mut busquedas = 0;
        usuarios.expect_buscar_por_sujeto().returning(move |_, _| {
            busquedas += 1;
            Ok((busquedas > 1).then(|| ganador.clone()))
        });
        usuarios
            .expect_guardar()
            .returning(|_| Err(ErrorRepositorio::Duplicado));

        // Actuar
        let principal = autenticador(usuarios).autenticar("good").await;

        // Comprobar
        assert_eq!(principal.map(|p| p.id_usuario), Ok(id.valor()));
    }

    #[tokio::test]
    async fn deberia_responder_no_disponible_cuando_no_se_pueden_leer_los_usuarios() {
        // Preparar
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios
            .expect_buscar_por_sujeto()
            .returning(|_, _| Err(ErrorRepositorio::NoDisponible));

        // Actuar
        let resultado = autenticador(usuarios).autenticar("good").await;

        // Comprobar
        assert_eq!(resultado, Err(ErrorAuth::NoDisponible));
    }

    #[tokio::test]
    async fn deberia_trasladar_la_respuesta_del_proveedor_cuando_rechaza_el_token() {
        // Preparar
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios.expect_buscar_por_sujeto().times(0);

        // Actuar
        let resultado = autenticador(usuarios).autenticar("old").await;

        // Comprobar
        assert_eq!(resultado, Err(ErrorAuth::Expirado));
    }
}