puerto 0.21.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 local`; desde entonces es tuyo.

use std::sync::Arc;

use async_trait::async_trait;
use puerto_nucleo::auth::{AlmacenCredenciales, HasherContrasena, Sesion, AlmacenSesiones};

use dominio_usuario::{
    errores::ErrorUsuario,
    modelo::{EMISOR_LOCAL, Usuario},
    repositorio::RepositorioUsuario,
};

pub struct LoginImpl {
    pub usuarios: Arc<dyn RepositorioUsuario>,
    pub credenciales: Arc<dyn AlmacenCredenciales>,
    pub hasher: Arc<dyn HasherContrasena>,
    pub sesiones: Arc<dyn AlmacenSesiones>,
}

#[async_trait]
impl Login for LoginImpl {
    async fn ejecutar(&self, params: ParamsLogin) -> Result<Sesion, ErrorUsuario> {
        tracing::info!("login: inicio");
        let sujeto = Usuario::sujeto_local(&params.email);
        let usuario = self.usuarios.buscar_por_sujeto(EMISOR_LOCAL, &sujeto).await?;
        let hash = match &usuario {
            Some(usuario) => self.credenciales.hash_contrasena(usuario.id.valor()).await?,
            None => None,
        };
        // Un email desconocido también se comprueba, contra un señuelo: los dos rechazos tardan lo
        // mismo, así que el tiempo de respuesta no delata qué emails tienen cuenta.
        let valido = self.hasher.verificar(&params.contrasena, hash).await;
        let Some(usuario) = usuario.filter(|_| valido) else {
            tracing::warn!("login: rechazado");
            return Err(ErrorUsuario::CredencialesInvalidas);
        };
        let sesion = self.sesiones.abrir(usuario.id.valor()).await?;
        tracing::info!(id = %usuario.id, "login: fin");
        Ok(sesion)
    }
}

#[cfg(test)]
mod tests {
    use chrono::Utc;
    use puerto_nucleo::auth::dobles::{MockAlmacenCredenciales, MockHasherContrasena, MockAlmacenSesiones};

    use super::*;
    use dominio_usuario::repositorio::dobles::MockRepositorioUsuario;

    /// Acepta `correct horse battery` contra el hash `stored`; rechaza cualquier otra cosa.
    fn hasher() -> MockHasherContrasena {
        let mut hasher = MockHasherContrasena::new();
        hasher.expect_verificar().times(1).returning(|contrasena, hash| {
            hash.as_deref() == Some("stored") && contrasena == "correct horse battery"
        });
        hasher
    }

    fn usuarios_con_ada() -> (MockRepositorioUsuario, Usuario) {
        let ada = Usuario::registrar("ada@example.com", None).expect("cuenta válida");
        let encontrado = ada.clone();
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios
            .expect_buscar_por_sujeto()
            .withf(|emisor, sujeto| emisor == EMISOR_LOCAL && sujeto == "ada@example.com")
            .returning(move |_, _| Ok(Some(encontrado.clone())));
        (usuarios, ada)
    }

    fn credenciales() -> MockAlmacenCredenciales {
        let mut credenciales = MockAlmacenCredenciales::new();
        credenciales
            .expect_hash_contrasena()
            .returning(|_| Ok(Some("stored".into())));
        credenciales
    }

    fn caso_de_uso(
        usuarios: MockRepositorioUsuario,
        credenciales: MockAlmacenCredenciales,
        sesiones: MockAlmacenSesiones,
    ) -> LoginImpl {
        LoginImpl {
            usuarios: Arc::new(usuarios),
            credenciales: Arc::new(credenciales),
            hasher: Arc::new(hasher()),
            sesiones: Arc::new(sesiones),
        }
    }

    fn params(email: &str, contrasena: &str) -> ParamsLogin {
        ParamsLogin {
            email: email.into(),
            contrasena: contrasena.into(),
        }
    }

    #[tokio::test]
    async fn deberia_abrir_una_sesion_para_la_cuenta_cuando_la_contrasena_coincide() {
        // Preparar
        let (usuarios, ada) = usuarios_con_ada();
        let mut sesiones = MockAlmacenSesiones::new();
        sesiones
            .expect_abrir()
            .withf(move |id_usuario| *id_usuario == ada.id.valor())
            .returning(|_| Ok(Sesion::new("opaque", Utc::now())));

        // Actuar
        let resultado = caso_de_uso(usuarios, credenciales(), sesiones)
            .ejecutar(params(" ADA@example.com", "correct horse battery"))
            .await;

        // Comprobar
        assert_eq!(resultado.expect("sesión iniciada").token, "opaque");
    }

    #[tokio::test]
    async fn deberia_rechazar_sin_abrir_sesion_cuando_la_contrasena_es_incorrecta() {
        // Preparar
        let (usuarios, _) = usuarios_con_ada();
        let mut sesiones = MockAlmacenSesiones::new();
        sesiones.expect_abrir().never();

        // Actuar
        let resultado = caso_de_uso(usuarios, credenciales(), sesiones)
            .ejecutar(params("ada@example.com", "tr0ub4dor&3 guess"))
            .await;

        // Comprobar
        assert_eq!(resultado.unwrap_err().to_string(), "auth.credenciales_invalidas");
    }

    #[tokio::test]
    async fn deberia_rechazar_igual_tras_comprobar_un_senuelo_cuando_el_email_es_desconocido() {
        // Preparar: se pregunta igualmente al hasher, sin hash.
        let mut usuarios = MockRepositorioUsuario::new();
        usuarios.expect_buscar_por_sujeto().returning(|_, _| Ok(None));
        let mut sesiones = MockAlmacenSesiones::new();
        sesiones.expect_abrir().never();

        // Actuar
        let resultado = caso_de_uso(usuarios, MockAlmacenCredenciales::new(), sesiones)
            .ejecutar(params("nobody@example.com", "correct horse battery"))
            .await;

        // Comprobar
        assert_eq!(resultado.unwrap_err().to_string(), "auth.credenciales_invalidas");
    }
}