//! 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(¶ms.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(¶ms.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");
}
}