use super::*;
use crate::auth::{Argon2idProfile, PasswordPolicy, PasswordVerificationLimits};
fn service(limits: PasswordWorkLimits) -> TokioPasswordService {
TokioPasswordService::new(
PasswordService::new().with_profile(Argon2idProfile::new(16, 1, 1, 32).unwrap()),
limits,
)
}
#[test]
fn admission_limits_reject_invalid_sizes_and_deadlines() {
for concurrency in [0, usize::MAX] {
assert!(matches!(
PasswordWorkLimits::new(concurrency),
Err(TokioPasswordError::InvalidConcurrency)
));
}
let limits = PasswordWorkLimits::new(2).unwrap();
assert_eq!(limits.concurrency(), 2);
assert_eq!(limits.max_waiters(), 0);
assert_eq!(limits.wait_timeout(), Duration::ZERO);
for (count, timeout) in [
(0, Duration::from_secs(1)),
(usize::MAX, Duration::from_secs(1)),
(1, Duration::ZERO),
(1, Duration::MAX),
] {
assert!(matches!(
limits.with_queue(count, timeout),
Err(TokioPasswordError::InvalidQueue)
));
}
}
#[test]
fn missing_tokio_runtime_is_an_error_instead_of_a_panic() {
use std::{
future::Future,
task::{Context, Poll, Waker},
};
let passwords = service(PasswordWorkLimits::new(1).unwrap());
let mut operation = std::pin::pin!(passwords.hash_password("secret".into()));
assert!(matches!(
operation
.as_mut()
.poll(&mut Context::from_waker(Waker::noop())),
Poll::Ready(Err(TokioPasswordError::NoRuntime))
));
}
#[tokio::test]
async fn hashes_verifies_and_rehashes_only_successfully_verified_passwords() {
let passwords = service(PasswordWorkLimits::new(1).unwrap());
let legacy = PasswordService::new()
.with_profile(Argon2idProfile::new(8, 1, 1, 32).unwrap())
.hash_password("correct password")
.unwrap();
let assessment = passwords
.verify_and_assess("correct password".into(), legacy.clone().into())
.await
.unwrap();
assert!(assessment.verified());
assert!(assessment.needs_rehash());
let rejected = passwords
.verify_and_rehash("wrong password".into(), legacy.clone().into())
.await
.unwrap();
assert!(!rejected.verification().verified());
assert!(rejected.replacement_hash().is_none());
let upgraded = passwords
.clone()
.verify_and_rehash("correct password".into(), legacy.into())
.await
.unwrap();
assert!(upgraded.verification().verified());
assert!(upgraded.verification().needs_rehash());
assert!(!format!("{upgraded:?}").contains("$argon2"));
let (_, replacement) = upgraded.into_parts();
let current = passwords
.verify_and_rehash("correct password".into(), replacement.unwrap())
.await
.unwrap();
assert!(current.verification().verified());
assert!(!current.verification().needs_rehash());
assert!(current.replacement_hash().is_none());
let hash = passwords
.hash_password("new password".into())
.await
.unwrap();
assert_eq!(format!("{hash:?}"), "[REDACTED]");
assert!(
passwords
.verify_password("new password".into(), hash.clone())
.await
.unwrap()
);
assert!(
!passwords
.verify_password("wrong password".into(), hash)
.await
.unwrap()
);
}
#[tokio::test]
async fn policy_and_hash_errors_survive_the_async_boundary() {
let sync = PasswordService::new().with_profile(Argon2idProfile::new(16, 1, 1, 32).unwrap());
let hash = sync.hash_password("secret").unwrap();
let passwords = TokioPasswordService::new(
sync.with_policy(
PasswordPolicy::new(8)
.unwrap()
.with_verification_limits(Some(PasswordVerificationLimits::new(8, 1, 1).unwrap())),
),
PasswordWorkLimits::new(1).unwrap(),
);
let error = passwords
.verify_password("secret".into(), hash.into())
.await
.unwrap_err();
assert!(matches!(
error,
TokioPasswordError::Password(PasswordError::VerificationCostExceeded { .. })
));
assert_eq!(error.error_kind(), ErrorKind::Validation);
assert_eq!(error.error_code(), "password_verification_cost_exceeded");
assert!(matches!(
passwords
.verify_password("secret".into(), "invalid".into())
.await,
Err(TokioPasswordError::Password(
PasswordError::InvalidPasswordHash
))
));
let _busy = passwords.inner.running.acquire().await.unwrap();
assert!(matches!(
passwords.hash_password("too long password".into()).await,
Err(TokioPasswordError::Password(
PasswordError::PasswordTooLong { max: 8 }
))
));
}
#[tokio::test]
async fn dummy_verification_is_cached_shared_and_subject_to_admission() {
let passwords = service(PasswordWorkLimits::new(1).unwrap());
assert!(passwords.inner.dummy_hash.get().is_none());
passwords
.verify_dummy_password("unknown".into())
.await
.unwrap();
let hash = passwords.inner.dummy_hash.get().unwrap().as_ref().unwrap();
passwords
.clone()
.verify_dummy_password("".into())
.await
.unwrap();
assert!(std::ptr::eq(
hash,
passwords.inner.dummy_hash.get().unwrap().as_ref().unwrap()
));
assert!(!format!("{passwords:?}").contains(hash.expose_secret()));
let _busy = passwords.inner.running.acquire().await.unwrap();
assert!(matches!(
passwords
.clone()
.verify_dummy_password("unknown".into())
.await,
Err(TokioPasswordError::Busy)
));
}
#[tokio::test]
async fn cancelling_a_running_caller_does_not_release_its_shared_budget() {
let passwords = service(PasswordWorkLimits::new(1).unwrap());
let (started, start) = tokio::sync::oneshot::channel();
let (release, finish) = std::sync::mpsc::channel();
let clone = passwords.clone();
let caller = tokio::spawn(async move {
clone
.run("secret".into(), move |_, _| {
started.send(()).unwrap();
let _ = finish.recv();
Ok(())
})
.await
});
start.await.unwrap();
caller.abort();
assert!(caller.await.unwrap_err().is_cancelled());
for _ in 0..3 {
assert!(matches!(
passwords.clone().hash_password("secret".into()).await,
Err(TokioPasswordError::Busy)
));
}
release.send(()).unwrap();
let permit = tokio::time::timeout(Duration::from_secs(5), passwords.inner.running.acquire())
.await
.unwrap()
.unwrap();
drop(permit);
assert!(passwords.hash_password("secret".into()).await.is_ok());
}
#[tokio::test(start_paused = true)]
async fn queue_bounds_timeouts_and_cancellation_prevent_unbounded_waiters() {
let passwords = service(
PasswordWorkLimits::new(1)
.unwrap()
.with_queue(1, Duration::from_secs(5))
.unwrap(),
);
let occupied = passwords.inner.running.acquire().await.unwrap();
let clone = passwords.clone();
let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
tokio::task::yield_now().await;
assert_eq!(passwords.inner.waiting.available_permits(), 0);
assert!(matches!(
passwords.clone().hash_password("secret".into()).await,
Err(TokioPasswordError::Busy)
));
waiting.abort();
assert!(waiting.await.unwrap_err().is_cancelled());
assert_eq!(passwords.inner.waiting.available_permits(), 1);
let clone = passwords.clone();
let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
tokio::task::yield_now().await;
tokio::time::advance(Duration::from_secs(5)).await;
let error = waiting.await.unwrap().unwrap_err();
assert!(matches!(error, TokioPasswordError::WaitTimeout));
assert_eq!(error.error_kind(), ErrorKind::Timeout);
assert_eq!(passwords.inner.waiting.available_permits(), 1);
let clone = passwords.clone();
let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
tokio::task::yield_now().await;
drop(occupied);
assert!(waiting.await.unwrap().is_ok());
assert_eq!(passwords.inner.waiting.available_permits(), 1);
assert_eq!(passwords.inner.running.available_permits(), 1);
}
#[tokio::test]
async fn worker_panics_release_the_budget_without_exposing_the_payload_in_errors() {
let passwords = service(PasswordWorkLimits::new(1).unwrap());
let error = passwords
.run::<()>("secret".into(), |_, _| panic!("private panic payload"))
.await
.unwrap_err();
assert!(matches!(error, TokioPasswordError::Task(_)));
assert!(!format!("{error:?} {error}").contains("private panic payload"));
assert!(passwords.hash_password("secret".into()).await.is_ok());
}