guise 0.1.2

Canonical browser fingerprint bundles, human-behavior timing, and TLS profile re-exports for the Santh fleet
Documentation
use std::collections::HashSet;
use std::sync::Arc;

use super::*;
use crate::fingerprint::StealthProfile;
use crate::fingerprint::browser_catalog::PROFILES;

#[test]
fn chrome_header_order_distinct_from_firefox_and_safari() {
    assert_ne!(CHROME_HEADER_ORDER.slots, FIREFOX_HEADER_ORDER.slots);
    assert_ne!(CHROME_HEADER_ORDER.slots, SAFARI_HEADER_ORDER.slots);
    assert_ne!(FIREFOX_HEADER_ORDER.slots, SAFARI_HEADER_ORDER.slots);
}

#[test]
fn chrome_orders_user_agent_after_sec_ch_ua_block() {
    let slots = CHROME_HEADER_ORDER.slots;
    let sec_ch_pos = slots.iter().position(|s| *s == "sec-ch-ua").unwrap();
    let ua_pos = slots.iter().position(|s| *s == "user-agent").unwrap();
    assert!(sec_ch_pos < ua_pos);
}

#[test]
fn safari_does_not_emit_sec_ch_headers() {
    for slot in SAFARI_HEADER_ORDER.slots {
        assert!(!slot.starts_with("sec-ch-"));
    }
}

#[test]
fn apply_in_order_promotes_canonical_slots_to_the_front() {
    let input = vec![
        ("X-Custom".into(), "junk".into()),
        ("Cookie".into(), "abc=1".into()),
        ("user-agent".into(), "chrome-fake".into()),
        ("Host".into(), "x.com".into()),
    ];
    let out = CHROME_HEADER_ORDER.apply_in_order(input);
    assert_eq!(out[0].0.to_ascii_lowercase(), "host");

    let ua_pos = out
        .iter()
        .position(|(name, _)| name.eq_ignore_ascii_case("user-agent"))
        .unwrap();
    let cookie_pos = out
        .iter()
        .position(|(name, _)| name.eq_ignore_ascii_case("cookie"))
        .unwrap();
    let custom_pos = out.iter().position(|(name, _)| name == "X-Custom").unwrap();
    assert!(ua_pos < cookie_pos);
    assert!(custom_pos > cookie_pos);
}

#[test]
fn apply_in_order_preserves_caller_casing_of_header_names() {
    let input = vec![
        ("User-Agent".into(), "x".into()),
        ("Accept-Language".into(), "en".into()),
    ];
    let out = CHROME_HEADER_ORDER.apply_in_order(input);
    assert!(out.iter().any(|(name, _)| name == "User-Agent"));
    assert!(out.iter().any(|(name, _)| name == "Accept-Language"));
}

#[test]
fn apply_in_order_keeps_duplicate_headers_in_input_order() {
    let input = vec![
        ("Cookie".into(), "first=1".into()),
        ("Cookie".into(), "second=2".into()),
    ];
    let out = CHROME_HEADER_ORDER.apply_in_order(input);
    let cookies: Vec<&str> = out
        .iter()
        .filter(|(name, _)| name.eq_ignore_ascii_case("cookie"))
        .map(|(_, value)| value.as_str())
        .collect();
    assert_eq!(cookies, vec!["first=1", "second=2"]);
}

#[test]
fn header_order_apply_with_every_slot_present() {
    let input: Vec<(String, String)> = CHROME_HEADER_ORDER
        .slots
        .iter()
        .map(|slot| ((*slot).to_string(), format!("v-{slot}")))
        .collect();
    let out = CHROME_HEADER_ORDER.apply_in_order(input);
    assert_eq!(out.len(), CHROME_HEADER_ORDER.slots.len());
    for (i, slot) in CHROME_HEADER_ORDER.slots.iter().enumerate() {
        assert_eq!(out[i].0.to_ascii_lowercase(), **slot);
    }
}

#[test]
fn header_order_apply_with_no_slots_present_preserves_input() {
    let input = vec![
        ("X-Custom-A".into(), "1".into()),
        ("X-Custom-B".into(), "2".into()),
        ("X-Custom-C".into(), "3".into()),
    ];
    let out = CHROME_HEADER_ORDER.apply_in_order(input.clone());
    assert_eq!(out, input);
}

#[test]
fn header_order_apply_is_idempotent() {
    let input = vec![
        ("User-Agent".into(), "chrome".into()),
        ("Host".into(), "x.com".into()),
        ("Cookie".into(), "a=1".into()),
    ];
    let pass1 = CHROME_HEADER_ORDER.apply_in_order(input);
    let pass2 = CHROME_HEADER_ORDER.apply_in_order(pass1.clone());
    assert_eq!(pass1, pass2);
}

#[test]
fn header_order_slots_have_no_duplicates_within_a_family() {
    for (name, slots) in [
        ("chrome", CHROME_HEADER_ORDER.slots),
        ("firefox", FIREFOX_HEADER_ORDER.slots),
        ("safari", SAFARI_HEADER_ORDER.slots),
    ] {
        let mut seen = HashSet::new();
        for slot in slots {
            assert!(seen.insert(*slot), "{name}: duplicate slot `{slot}`");
        }
    }
}

#[test]
fn h2_profiles_have_distinct_initial_window_increments() {
    assert_ne!(
        CHROME_H2.initial_window_increment,
        FIREFOX_H2.initial_window_increment
    );
    assert_ne!(
        CHROME_H2.initial_window_increment,
        SAFARI_H2.initial_window_increment
    );
    assert_ne!(
        FIREFOX_H2.initial_window_increment,
        SAFARI_H2.initial_window_increment
    );
}

#[test]
fn chrome_h2_disables_push_explicitly() {
    assert!(CHROME_H2
        .settings
        .iter()
        .any(|&(id, value)| id == 2 && value == 0));
    assert!(!FIREFOX_H2.settings.iter().any(|&(id, _)| id == 2));
    assert!(!SAFARI_H2.settings.iter().any(|&(id, _)| id == 2));
}

#[test]
fn safari_h2_carries_enable_connect_protocol_setting() {
    assert!(SAFARI_H2.settings.iter().any(|&(id, _)| id == 8));
    assert!(!CHROME_H2.settings.iter().any(|&(id, _)| id == 8));
    assert!(!FIREFOX_H2.settings.iter().any(|&(id, _)| id == 8));
}

#[test]
fn pair_for_name_recognises_canonical_aliases() {
    for alias in ["chrome", "chrome131", "Chrome", "edge131", "EDGE"] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "chrome");
    }
    for alias in ["firefox", "Firefox133", "FIREFOX"] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "firefox");
    }
    for alias in ["safari", "safari18", "Safari17_5"] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "safari");
    }
    assert!(pair_for_name("unknown-browser").is_none());
    assert!(pair_for_name("").is_none());
}

#[test]
fn pair_for_name_resolves_full_stealth_profile_aliases() {
    for alias in [
        "chrome-android",
        "chrome-linux",
        "brave",
        "opera",
        "samsung-internet",
    ] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "chrome");
    }
    for alias in ["firefox-windows", "firefox-linux"] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "firefox");
    }
    for alias in ["safari-iphone", "safari-ipad", "safari"] {
        assert_eq!(pair_for_name(alias).unwrap().0.family, "safari");
    }
    assert!(pair_for_name("ie11").is_none());
}

#[test]
fn pair_for_profile_maps_canonical_profiles_to_browser_family() {
    for profile in [
        StealthProfile::ChromeWindowsStable,
        StealthProfile::ChromeWindowsLegacy96,
        StealthProfile::ChromeMacStable,
        StealthProfile::EdgeWindowsStable,
        StealthProfile::ChromeAndroid,
        StealthProfile::ChromeLinux,
        StealthProfile::BraveWindows,
        StealthProfile::OperaWindows,
        StealthProfile::SamsungInternetAndroid,
    ] {
        assert_eq!(pair_for_profile(profile).unwrap().0.family, "chrome");
    }
    for profile in [StealthProfile::FirefoxLinux, StealthProfile::FirefoxWindows] {
        assert_eq!(pair_for_profile(profile).unwrap().0.family, "firefox");
    }
    for profile in [
        StealthProfile::SafariIphone,
        StealthProfile::SafariIpad,
        StealthProfile::SafariMacStable,
    ] {
        assert_eq!(pair_for_profile(profile).unwrap().0.family, "safari");
    }
    assert!(pair_for_profile(StealthProfile::Ie11Windows).is_none());
}

#[test]
fn header_order_and_h2_profile_pair_share_family_string() {
    for alias in ["chrome", "firefox", "safari"] {
        let (header_order, h2_profile) = pair_for_name(alias).unwrap();
        assert_eq!(header_order.family, h2_profile.family);
    }
}

#[test]
fn session_pool_returns_same_profile_for_same_host_until_rotation() {
    let pool = SessionPool::new(PROFILES.iter().collect(), 10);
    let first = pool.profile_for("a.com").name;
    for _ in 0..8 {
        assert_eq!(pool.profile_for("a.com").name, first);
    }
    let _ = pool.profile_for("a.com");
    let (_, _, count) = pool
        .snapshot()
        .into_iter()
        .find(|(host, _, _)| host == "a.com")
        .unwrap();
    assert!(count <= 2);
}

#[test]
fn session_pool_assigns_different_hosts_round_robin() {
    let pool = SessionPool::new(PROFILES.iter().collect(), 100);
    let a = pool.profile_for("a.com").name;
    let b = pool.profile_for("b.com").name;
    assert_ne!(a, b);
}

#[test]
fn session_pool_clear_drops_bindings() {
    let pool = SessionPool::new(PROFILES.iter().collect(), 100);
    let _ = pool.profile_for("a.com");
    let _ = pool.profile_for("b.com");
    assert_eq!(pool.snapshot().len(), 2);
    pool.clear();
    assert!(pool.snapshot().is_empty());
}

#[test]
fn session_pool_zero_rotate_coerces_to_one_not_panic() {
    let pool = SessionPool::new(PROFILES.iter().collect(), 0);
    let _ = pool.profile_for("a.com");
    let _ = pool.profile_for("a.com");
}

#[test]
#[should_panic(expected = "requires at least one profile")]
fn session_pool_empty_profiles_panics_explicitly() {
    let _ = SessionPool::new(vec![], 5);
}

#[test]
fn session_pool_under_concurrent_lookups_remains_consistent() {
    let pool = Arc::new(SessionPool::new(PROFILES.iter().collect(), 50));
    let mut handles = Vec::new();
    for i in 0..20 {
        let pool = Arc::clone(&pool);
        handles.push(std::thread::spawn(move || {
            let host = if i % 2 == 0 { "a.com" } else { "b.com" };
            let mut names = HashSet::new();
            for _ in 0..25 {
                names.insert(pool.profile_for(host).name);
            }
            (host, names)
        }));
    }

    let mut a_names = HashSet::new();
    let mut b_names = HashSet::new();
    for handle in handles {
        let (host, names) = handle.join().unwrap();
        if host == "a.com" {
            a_names.extend(names);
        } else {
            b_names.extend(names);
        }
    }
    assert!(a_names.len() <= PROFILES.len());
    assert!(b_names.len() <= PROFILES.len());
}

#[test]
fn session_pool_rotate_one_does_rotate_each_call() {
    let pool = SessionPool::new(PROFILES.iter().collect(), 1);
    let _ = pool.profile_for("a.com");
    let _ = pool.profile_for("a.com");
    let (_, _, count) = pool
        .snapshot()
        .into_iter()
        .find(|(host, _, _)| host == "a.com")
        .unwrap();
    assert!(count <= 2);
}

#[test]
fn session_pool_counter_never_exceeds_rotate_after_requests() {
    let rotate_at = 5;
    let pool = Arc::new(SessionPool::new(PROFILES.iter().collect(), rotate_at));
    let mut handles = Vec::new();
    for _ in 0..40 {
        let pool = Arc::clone(&pool);
        handles.push(std::thread::spawn(move || {
            pool.profile_for("toctou.com");
        }));
    }
    for handle in handles {
        handle.join().unwrap();
    }
    if let Some((_, _, count)) = pool
        .snapshot()
        .iter()
        .find(|(host, _, _)| host == "toctou.com")
    {
        assert!(*count < rotate_at);
    }
}

#[test]
fn session_pool_counter_resets_after_rotation_boundary() {
    let rotate_at = 3;
    let pool = SessionPool::new(PROFILES.iter().collect(), rotate_at);
    let _ = pool.profile_for("boundary.com");
    let _ = pool.profile_for("boundary.com");
    let _ = pool.profile_for("boundary.com");
    let (_, _, count) = pool
        .snapshot()
        .into_iter()
        .find(|(host, _, _)| host == "boundary.com")
        .unwrap();
    assert_eq!(count, 1);
}

#[test]
fn session_pool_single_host_many_calls_stays_within_rotate_limit() {
    let rotate_at = 4;
    let pool = SessionPool::new(PROFILES.iter().collect(), rotate_at);
    for _ in 0..50 {
        let _ = pool.profile_for("single.com");
        if let Some((_, _, count)) = pool
            .snapshot()
            .iter()
            .find(|(host, _, _)| host == "single.com")
        {
            assert!(*count < rotate_at);
        }
    }
}

#[test]
fn session_pool_snapshot_does_not_lose_bindings_under_contention() {
    let pool = Arc::new(SessionPool::new(PROFILES.iter().collect(), 100));
    let hosts: Vec<String> = (0..100).map(|i| format!("host-{i}.com")).collect();
    let mut handles = Vec::new();
    for host in &hosts {
        let pool = Arc::clone(&pool);
        let host = host.clone();
        handles.push(std::thread::spawn(move || {
            let _ = pool.profile_for(&host);
        }));
    }
    for handle in handles {
        handle.join().unwrap();
    }

    let snapshot = pool.snapshot();
    assert_eq!(snapshot.len(), 100);
    let snapshot_hosts: HashSet<String> =
        snapshot.iter().map(|(host, _, _)| host.clone()).collect();
    for host in &hosts {
        assert!(snapshot_hosts.contains(host));
    }
}