use super::*;
use crate::fingerprint::profile_facts;
fn make_injector() -> NoiseInjector {
NoiseInjector::new(BehavioralProfile::chrome_us(), 0xDEAD_BEEF)
}
fn header_value<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
headers
.iter()
.find(|(header_name, _)| header_name.eq_ignore_ascii_case(name))
.map(|(_, value)| value.as_str())
}
fn canonical_header(profile: StealthProfile, name: &str) -> String {
browser_request_headers(profile, BrowserRequestKind::Navigation)
.into_iter()
.find(|header| header.name.eq_ignore_ascii_case(name))
.unwrap_or_else(|| panic!("{profile:?} missing canonical {name} header"))
.value
}
fn single_mode_profile(mode: &'static str) -> BehavioralProfile {
BehavioralProfile {
name: "single_mode",
stealth_profile: Some(StealthProfile::ChromeWindowsStable),
accept_language_variants: vec![("en-US,en;q=0.9", 1.0)],
user_agent_pool: vec![profile_user_agent(StealthProfile::ChromeWindowsStable)],
referer_pool: vec![""],
timing: (100.0, 10.0),
sec_fetch_mode: vec![mode],
emit_client_hints: true,
sec_ch_ua: None,
}
}
#[test]
fn inject_adds_user_agent() {
let mut injector = make_injector();
let mut headers: Vec<(String, String)> = Vec::new();
injector.inject(&mut headers);
assert!(
headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("user-agent")),
"user-agent must be injected"
);
}
#[test]
fn inject_adds_accept_language() {
let mut injector = make_injector();
let mut headers = Vec::new();
injector.inject(&mut headers);
assert!(headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("accept-language")));
}
#[test]
fn inject_adds_accept_encoding() {
let mut injector = make_injector();
let mut headers = Vec::new();
injector.inject(&mut headers);
assert!(headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("accept-encoding")));
}
#[test]
fn inject_adds_sec_fetch_mode() {
let mut injector = make_injector();
let mut headers = Vec::new();
injector.inject(&mut headers);
assert!(headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("sec-fetch-mode")));
}
#[test]
fn inject_navigation_surface_delegates_to_catalog() {
let mut injector = NoiseInjector::new(single_mode_profile("navigate"), 1);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(
header_value(&headers, "accept"),
Some(profile_facts(StealthProfile::ChromeWindowsStable).accept)
);
assert_eq!(header_value(&headers, "sec-fetch-dest"), Some("document"));
assert_eq!(header_value(&headers, "sec-fetch-mode"), Some("navigate"));
assert_eq!(header_value(&headers, "sec-fetch-site"), Some("none"));
assert_eq!(header_value(&headers, "sec-fetch-user"), Some("?1"));
assert_eq!(
header_value(&headers, "upgrade-insecure-requests"),
Some("1")
);
}
#[test]
fn inject_no_cors_surface_uses_catalog_image_shape() {
let mut injector = NoiseInjector::new(single_mode_profile("no-cors"), 1);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "accept"), Some("*/*"));
assert_eq!(header_value(&headers, "sec-fetch-dest"), Some("image"));
assert_eq!(header_value(&headers, "sec-fetch-mode"), Some("no-cors"));
assert_eq!(header_value(&headers, "sec-fetch-site"), Some("cross-site"));
assert_eq!(header_value(&headers, "sec-fetch-user"), None);
assert_eq!(header_value(&headers, "upgrade-insecure-requests"), None);
}
#[test]
fn inject_clears_stale_navigation_only_surface_headers() {
let mut injector = NoiseInjector::new(single_mode_profile("cors"), 1);
let mut headers = vec![
("Sec-Fetch-User".to_string(), "?1".to_string()),
("Upgrade-Insecure-Requests".to_string(), "1".to_string()),
];
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "sec-fetch-mode"), Some("cors"));
assert_eq!(header_value(&headers, "sec-fetch-dest"), Some("empty"));
assert_eq!(header_value(&headers, "sec-fetch-site"), Some("cross-site"));
assert_eq!(header_value(&headers, "sec-fetch-user"), None);
assert_eq!(header_value(&headers, "upgrade-insecure-requests"), None);
}
#[test]
fn inject_chrome_emits_canonical_client_hints() {
let mut injector = make_injector();
let mut headers = Vec::new();
injector.inject(&mut headers);
let sec_ch_ua = header_value(&headers, "sec-ch-ua");
let expected_sec_ch_ua = canonical_header(StealthProfile::ChromeWindowsStable, "Sec-CH-UA");
assert_eq!(sec_ch_ua, Some(expected_sec_ch_ua.as_str()));
assert!(sec_ch_ua.is_some_and(|value| value.contains("131")));
assert!(!sec_ch_ua.is_some_and(|value| value.contains("\"130\"")));
let expected_platform =
canonical_header(StealthProfile::ChromeWindowsStable, "Sec-CH-UA-Platform");
let expected_mobile = canonical_header(StealthProfile::ChromeWindowsStable, "Sec-CH-UA-Mobile");
assert_eq!(
header_value(&headers, "sec-ch-ua-platform"),
Some(expected_platform.as_str())
);
assert_eq!(
header_value(&headers, "sec-ch-ua-mobile"),
Some(expected_mobile.as_str())
);
}
#[test]
fn explicit_custom_client_hint_override_is_preserved() {
let profile = BehavioralProfile {
name: "custom_chromium",
stealth_profile: None,
accept_language_variants: vec![("en-US,en;q=0.9", 1.0)],
user_agent_pool: vec!["Mozilla/5.0 (Windows NT 10.0) Chrome/1.0 Safari/537.36"],
referer_pool: vec![""],
timing: (100.0, 10.0),
sec_fetch_mode: vec!["navigate"],
emit_client_hints: true,
sec_ch_ua: Some(r#""Custom Browser";v="1""#),
};
let mut injector = NoiseInjector::new(profile, 7);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(
header_value(&headers, "sec-ch-ua"),
Some(r#""Custom Browser";v="1""#)
);
assert_eq!(header_value(&headers, "sec-ch-ua-mobile"), Some("?0"));
assert_eq!(
header_value(&headers, "sec-ch-ua-platform"),
Some("\"Windows\"")
);
}
#[test]
fn typed_stealth_profile_drives_session_catalog_over_user_agent_guess() {
let profile = BehavioralProfile {
name: "typed_override",
stealth_profile: Some(StealthProfile::ChromeAndroid),
accept_language_variants: vec![("en-US,en;q=0.9", 1.0)],
user_agent_pool: vec![profile_user_agent(StealthProfile::ChromeWindowsStable)],
referer_pool: vec![""],
timing: (100.0, 10.0),
sec_fetch_mode: vec!["navigate"],
emit_client_hints: true,
sec_ch_ua: Some(r#""Typed Browser";v="1""#),
};
let mut injector = NoiseInjector::new(profile, 7);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "sec-ch-ua-mobile"), Some("?1"));
assert_eq!(
header_value(&headers, "sec-ch-ua-platform"),
Some("\"Android\"")
);
}
#[test]
fn inject_firefox_no_client_hints() {
let mut injector = NoiseInjector::new(BehavioralProfile::firefox_eu(), 42);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert!(!headers
.iter()
.any(|(name, _)| name.eq_ignore_ascii_case("sec-ch-ua")));
}
#[test]
fn inject_does_not_overwrite_attack_headers() {
let mut injector = make_injector();
let mut headers = vec![("x-attack-payload".to_string(), "' OR 1=1--".to_string())];
injector.inject(&mut headers);
assert!(headers
.iter()
.any(|(name, value)| name == "x-attack-payload" && value == "' OR 1=1--"));
}
#[test]
fn inject_replaces_existing_user_agent() {
let mut injector = make_injector();
let mut headers = vec![("user-agent".to_string(), "wafrift-bot/1.0".to_string())];
injector.inject(&mut headers);
let ua = header_value(&headers, "user-agent").expect("user-agent header");
assert_ne!(ua, "wafrift-bot/1.0");
assert!(ua.contains("Mozilla"), "new UA must be browser-like: {ua}");
}
#[test]
fn inject_preserves_existing_accept_headers_case_insensitively() {
let mut injector = make_injector();
let mut headers = vec![
("ACCEPT".to_string(), "application/json".to_string()),
("Accept-Encoding".to_string(), "identity".to_string()),
];
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "accept"), Some("application/json"));
assert_eq!(header_value(&headers, "accept-encoding"), Some("identity"));
assert_eq!(
headers
.iter()
.filter(|(name, _)| name.eq_ignore_ascii_case("accept"))
.count(),
1
);
assert_eq!(
headers
.iter()
.filter(|(name, _)| name.eq_ignore_ascii_case("accept-encoding"))
.count(),
1
);
}
#[test]
fn inject_user_agent_is_stable_across_calls() {
let mut injector = make_injector();
let mut first_headers = Vec::new();
let mut second_headers = Vec::new();
injector.inject(&mut first_headers);
injector.inject(&mut second_headers);
assert_eq!(
header_value(&first_headers, "user-agent"),
header_value(&second_headers, "user-agent")
);
}
#[test]
fn inject_accept_language_is_stable() {
let mut injector = make_injector();
let mut first_headers = Vec::new();
let mut second_headers = Vec::new();
injector.inject(&mut first_headers);
injector.inject(&mut second_headers);
assert_eq!(
header_value(&first_headers, "accept-language"),
header_value(&second_headers, "accept-language")
);
}
#[test]
fn timing_is_positive_and_capped() {
let mut injector = make_injector();
for _ in 0..20 {
let timing = injector.next_timing();
assert!(timing.sleep_ms >= 50, "sleep must be >= 50ms");
assert!(timing.sleep_ms <= 8000, "sleep must be <= 8000ms");
}
}
#[test]
fn request_count_increments() {
let mut injector = make_injector();
assert_eq!(injector.request_count(), 0);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(injector.request_count(), 1);
injector.inject(&mut headers);
assert_eq!(injector.request_count(), 2);
}
#[test]
fn set_current_url_affects_referer() {
let mut injector = make_injector();
injector.set_current_url("https://target.example.com/page");
let mut headers = Vec::new();
injector.inject(&mut headers);
let mut saw_referer = false;
for _ in 0..30 {
let mut next_headers = Vec::new();
injector.inject(&mut next_headers);
if let Some(value) = header_value(&next_headers, "referer") {
if value.contains("target.example.com") {
saw_referer = true;
break;
}
}
}
assert!(saw_referer);
}
#[test]
fn safari_profile_constructs() {
let profile = BehavioralProfile::safari_us();
assert_eq!(profile.name, "safari_macos_us");
assert!(!profile.emit_client_hints);
assert!(profile.sec_ch_ua.is_none());
}
#[test]
fn android_profile_constructs() {
let profile = BehavioralProfile::chrome_android();
assert!(profile.emit_client_hints);
assert!(profile.sec_ch_ua.is_none());
assert!(!profile.user_agent_pool.is_empty());
assert!(profile
.user_agent_pool
.iter()
.any(|ua| ua.contains("Android")));
}
#[test]
fn all_profiles_have_non_empty_ua_pool() {
for profile in [
BehavioralProfile::chrome_us(),
BehavioralProfile::firefox_eu(),
BehavioralProfile::safari_us(),
BehavioralProfile::chrome_android(),
] {
assert!(
!profile.user_agent_pool.is_empty(),
"{} has empty UA pool",
profile.name
);
}
}
#[test]
fn built_in_profiles_use_canonical_stealth_user_agents() {
let cases = [
(
BehavioralProfile::chrome_us(),
profile_user_agent(StealthProfile::ChromeWindowsStable),
),
(
BehavioralProfile::firefox_eu(),
profile_user_agent(StealthProfile::FirefoxLinux),
),
(
BehavioralProfile::safari_us(),
profile_user_agent(StealthProfile::SafariMacStable),
),
(
BehavioralProfile::chrome_android(),
profile_user_agent(StealthProfile::ChromeAndroid),
),
];
for (profile, user_agent) in cases {
assert_eq!(
profile.user_agent_pool,
vec![user_agent],
"{} must delegate UA selection to stealth",
profile.name
);
}
}
#[test]
fn built_in_profiles_carry_typed_stealth_profiles() {
let cases = [
(
BehavioralProfile::chrome_us(),
StealthProfile::ChromeWindowsStable,
),
(
BehavioralProfile::firefox_eu(),
StealthProfile::FirefoxLinux,
),
(
BehavioralProfile::safari_us(),
StealthProfile::SafariMacStable,
),
(
BehavioralProfile::chrome_android(),
StealthProfile::ChromeAndroid,
),
];
for (profile, stealth_profile) in cases {
assert_eq!(
profile.stealth_profile,
Some(stealth_profile),
"{} must carry the shared profile that owns its browser surface",
profile.name
);
}
}
#[test]
fn built_in_profiles_use_canonical_stealth_header_facts() {
let cases = [
(
BehavioralProfile::chrome_us(),
StealthProfile::ChromeWindowsStable,
),
(
BehavioralProfile::firefox_eu(),
StealthProfile::FirefoxLinux,
),
(
BehavioralProfile::safari_us(),
StealthProfile::SafariMacStable,
),
(
BehavioralProfile::chrome_android(),
StealthProfile::ChromeAndroid,
),
];
for (profile, stealth_profile) in cases {
let facts = profile_facts(stealth_profile);
let mut navigation_profile = profile.clone();
navigation_profile.sec_fetch_mode = vec!["navigate"];
let mut injector = NoiseInjector::new(navigation_profile, 42);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "accept"), Some(facts.accept));
assert_eq!(
header_value(&headers, "accept-encoding"),
Some(facts.accept_encoding)
);
}
}
#[test]
fn built_in_chromium_client_hints_delegate_to_stealth() {
let cases = [
(
BehavioralProfile::chrome_us(),
StealthProfile::ChromeWindowsStable,
),
(
BehavioralProfile::chrome_android(),
StealthProfile::ChromeAndroid,
),
];
for (profile, stealth_profile) in cases {
let mut injector = NoiseInjector::new(profile.clone(), 42);
let mut headers = Vec::new();
injector.inject(&mut headers);
for name in ["Sec-CH-UA", "Sec-CH-UA-Mobile", "Sec-CH-UA-Platform"] {
let expected = canonical_header(stealth_profile, name);
assert_eq!(
header_value(&headers, name),
Some(expected.as_str()),
"{} {name} drifted from stealth",
profile.name
);
}
}
}
#[test]
fn android_client_hint_marks_mobile() {
let mut injector = NoiseInjector::new(BehavioralProfile::chrome_android(), 42);
let mut headers = Vec::new();
injector.inject(&mut headers);
assert_eq!(header_value(&headers, "sec-ch-ua-mobile"), Some("?1"));
}
#[test]
fn accept_language_weighted_sampling_is_stable() {
let mut first_rng = StdRng::seed_from_u64(99);
let mut second_rng = StdRng::seed_from_u64(99);
let profile = BehavioralProfile::chrome_us();
let variants = &profile.accept_language_variants;
let first = sample_accept_language(variants, &mut first_rng);
let second = sample_accept_language(variants, &mut second_rng);
assert_eq!(first, second);
}
#[test]
fn accept_language_invalid_weights_use_default_fallback() {
let mut rng = StdRng::seed_from_u64(101);
let variants = &[
("invalid;q=1.0", 0.0),
("also-invalid;q=1.0", f64::NAN),
("negative-invalid;q=1.0", -1.0),
];
assert_eq!(sample_accept_language(variants, &mut rng), "en-US,en;q=0.9");
}
#[test]
fn profile_name_is_accessible() {
let injector = make_injector();
assert_eq!(injector.profile_name(), "chrome_windows_us");
}