use super::*;
#[test]
fn minimum_length_is_explicit_and_counts_unicode_scalars() {
assert_eq!(
PasswordPolicy::new(0),
Err(PasswordPolicyError::InvalidMinimumLength)
);
let policy = PasswordPolicy::new(3).unwrap();
assert_eq!(policy.min_length(), 3);
for short in ["", "ab", "密码", "🦀🦀", "é"] {
assert_eq!(
policy.validate(short),
Err(PasswordPolicyError::TooShort { min: 3 })
);
}
for accepted in ["abc", "密码学", "🦀🦀🦀", "e\u{301}a", " "] {
assert_eq!(policy.validate(accepted), Ok(()));
}
}
#[test]
fn custom_list_uses_whole_passwords_and_only_folds_ascii() {
let policy = PasswordPolicy::new(1)
.unwrap()
.with_blocklist(["password", "Éclair", " spaced ", "猫ABC", "Straße", "\0"]);
for blocked in ["PASSWORD", "ÉCLAIR", " SpAcEd ", "猫aBc", "STRAßE", "\0"] {
assert_eq!(
policy.validate(blocked),
Err(PasswordPolicyError::BlockedPassword)
);
}
for accepted in [
"password in a unique long passphrase",
"password ",
" password",
"éclair",
"E\u{301}clair",
"spaced",
"STRASSE",
"猫ABC猫",
] {
assert_eq!(policy.validate(accepted), Ok(()));
}
}
#[test]
fn custom_list_is_owned_deduplicated_and_replaced_without_mutating_clones() {
let mut entries = vec!["Zulu".to_owned(), "alpha".to_owned(), "ALPHA".to_owned()];
let policy = PasswordPolicy::new(1).unwrap().with_blocklist(&entries);
entries.clear();
assert_eq!(policy.blocklist.len(), 2);
let clone = policy.clone();
assert!(Arc::ptr_eq(&policy.blocklist, &clone.blocklist));
let replaced = clone.with_blocklist(["new entry"]);
assert_eq!(replaced.validate("zulu"), Ok(()));
assert_eq!(
replaced.validate("NEW ENTRY"),
Err(PasswordPolicyError::BlockedPassword)
);
assert_eq!(
policy.validate("zulu"),
Err(PasswordPolicyError::BlockedPassword)
);
let cleared = policy.with_blocklist(std::iter::empty::<&str>());
assert_eq!(cleared.validate("alpha"), Ok(()));
}
#[test]
fn minimum_length_precedes_blocklist_rejections() {
let policy = PasswordPolicy::new(12)
.unwrap()
.with_blocklist(["password"]);
assert_eq!(
policy.validate("password"),
Err(PasswordPolicyError::TooShort { min: 12 })
);
}
#[test]
fn repeated_character_check_is_opt_in_and_can_be_disabled() {
let policy = PasswordPolicy::new(15).unwrap();
assert!(!policy.repeated_character_check_enabled());
assert_eq!(policy.validate(&"a".repeat(15)), Ok(()));
assert_eq!(policy.validate(&"猫".repeat(15)), Ok(()));
let enabled = policy.with_repeated_character_check(true);
assert!(enabled.repeated_character_check_enabled());
let disabled = enabled.clone().with_repeated_character_check(false);
assert!(!disabled.repeated_character_check_enabled());
for character in ["a", "猫", "é", "🦀", " ", "\0"] {
let password = character.repeat(15);
assert_eq!(
enabled.validate(&password),
Err(PasswordPolicyError::RepeatedCharacter)
);
assert_eq!(disabled.validate(&password), Ok(()));
}
}
#[test]
fn repeated_character_check_requires_two_identical_scalars_and_the_entire_password() {
let policy = PasswordPolicy::new(1)
.unwrap()
.with_repeated_character_check(true);
assert_eq!(
policy.validate(""),
Err(PasswordPolicyError::TooShort { min: 1 })
);
for password in [
"a",
"é",
"猫",
"🦀",
" ",
"\u{301}",
"Aa",
"aA",
"abab",
"e\u{301}e\u{301}",
"ééx",
"aaaab",
" x ",
] {
assert_eq!(policy.validate(password), Ok(()), "{password:?}");
}
for password in ["aa", "éé", "猫猫", "🦀🦀", " ", "\u{301}\u{301}"] {
assert_eq!(
policy.validate(password),
Err(PasswordPolicyError::RepeatedCharacter)
);
}
}
#[test]
fn repeated_character_errors_follow_length_and_precede_blocklist_errors() {
let policy = PasswordPolicy::new(4)
.unwrap()
.with_repeated_character_check(true)
.with_blocklist(["aaa", "aaaa", "blocked"]);
assert_eq!(
policy.validate("aaa"),
Err(PasswordPolicyError::TooShort { min: 4 })
);
assert_eq!(
policy.validate("aaaa"),
Err(PasswordPolicyError::RepeatedCharacter)
);
assert_eq!(
policy.validate("blocked"),
Err(PasswordPolicyError::BlockedPassword)
);
let policy = policy.with_repeated_character_check(false);
assert_eq!(
policy.validate("aaaa"),
Err(PasswordPolicyError::BlockedPassword)
);
assert_eq!(
policy.validate("blocked"),
Err(PasswordPolicyError::BlockedPassword)
);
}
#[test]
fn diagnostics_do_not_expose_passwords_or_custom_entries() {
let secret = "private-application-blocklist-value";
let policy = PasswordPolicy::new(15).unwrap().with_blocklist([secret]);
let error = policy.validate(secret).unwrap_err();
assert!(!format!("{policy:?}").contains(secret));
for formatted in [format!("{error:?}"), error.to_string()] {
assert!(!formatted.contains(secret));
}
for (error, code) in [
(
PasswordPolicyError::InvalidMinimumLength,
"invalid_password_minimum_length",
),
(
PasswordPolicyError::TooShort { min: 15 },
"password_too_short",
),
(PasswordPolicyError::BlockedPassword, "password_blocked"),
(PasswordPolicyError::CommonPassword, "password_too_common"),
(
PasswordPolicyError::RepeatedCharacter,
"password_repeated_character",
),
] {
assert_eq!(error.error_kind(), ErrorKind::Validation);
assert_eq!(error.error_code().as_str(), code);
}
}
#[cfg(feature = "password-common")]
#[test]
fn repeated_character_check_is_independent_of_the_common_password_list() {
let repeated = "a".repeat(15);
let policy = PasswordPolicy::new(15).unwrap().with_common_passwords(true);
assert_eq!(policy.validate(&repeated), Ok(()));
let policy = policy.with_repeated_character_check(true);
assert_eq!(
policy.validate(&repeated),
Err(PasswordPolicyError::RepeatedCharacter)
);
assert_eq!(
policy.validate("111111111111111"),
Err(PasswordPolicyError::RepeatedCharacter)
);
let policy = policy.with_common_passwords(false);
assert_eq!(
policy.validate(&repeated),
Err(PasswordPolicyError::RepeatedCharacter)
);
let policy = policy
.with_common_passwords(true)
.with_repeated_character_check(false);
assert_eq!(
policy.validate("111111111111111"),
Err(PasswordPolicyError::CommonPassword)
);
}
#[cfg(feature = "password-common")]
#[test]
fn bundled_data_is_sorted_unique_and_ascii_folded() {
use super::common_passwords::COMMON_PASSWORDS;
assert_eq!(COMMON_PASSWORDS.len(), 19_640);
assert!(COMMON_PASSWORDS.windows(2).all(|pair| pair[0] < pair[1]));
let policy = PasswordPolicy::new(1).unwrap().with_common_passwords(true);
for &entry in COMMON_PASSWORDS {
assert!(!entry.is_empty());
assert!(!entry.bytes().any(|byte| byte.is_ascii_uppercase()));
assert_eq!(
policy.validate(entry),
Err(PasswordPolicyError::CommonPassword)
);
assert_eq!(
policy.validate(&entry.to_ascii_uppercase()),
Err(PasswordPolicyError::CommonPassword)
);
}
}
#[cfg(feature = "password-common")]
#[test]
fn common_passwords_are_opt_in_and_custom_rejections_take_precedence() {
let policy = PasswordPolicy::new(8).unwrap();
assert!(!policy.common_passwords_enabled());
assert_eq!(policy.validate("password"), Ok(()));
let policy = policy.with_common_passwords(true);
assert!(policy.common_passwords_enabled());
assert_eq!(
policy.validate("PaSsWoRd"),
Err(PasswordPolicyError::CommonPassword)
);
assert_eq!(
policy.validate("a distinct long phrase containing password"),
Ok(())
);
assert_eq!(policy.validate(" password "), Ok(()));
let policy = policy.with_blocklist(["password", "application-specific"]);
assert_eq!(
policy.validate("PASSWORD"),
Err(PasswordPolicyError::BlockedPassword)
);
let policy = policy.with_common_passwords(false);
assert_eq!(
policy.validate("application-specific"),
Err(PasswordPolicyError::BlockedPassword)
);
let policy = policy.with_blocklist(std::iter::empty::<&str>());
assert_eq!(policy.validate("password"), Ok(()));
}