footing 0.5.3

Feature-gated foundations for Rust backend services
Documentation
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(()));
}