Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
125 KB
Raw Blame
use super::BrokeredCredentialProvider;
use super::CredentialAuthMethod;
use super::CredentialBroker;
use super::CredentialProviderConfig;
use super::brokered_credential_marker_env_keys;
use super::brokered_credential_value_env_keys;
use crate::NetworkProxyConfig;
use base64::Engine as _;
use pretty_assertions::assert_eq;
use rama_http::HeaderMap;
use rama_http::HeaderValue;
use rama_http::header::AUTHORIZATION;
use std::collections::BTreeMap;
use std::collections::HashMap;

fn broker_for(provider: CredentialProviderConfig) -> CredentialBroker {
    let broker = CredentialBroker::new(/*enabled*/ true);
    broker.configure(&NetworkProxyConfig {
        credential_broker: true,
        credential_providers: BTreeMap::from([("custom".to_string(), provider)]),
        ..NetworkProxyConfig::default()
    });
    broker
}

#[test]
fn adjacent_credentials_keep_original_boundaries() {
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
        patterns: vec![
            r"^(?:first_a{30}-|first_[b-z]{30}x)$".to_string(),
            r"\bsecond_[a-z]{20}\b".to_string(),
        ],
        url_prefixes: vec!["https://provider.example/v1".to_string()],
        ..CredentialProviderConfig::default()
    });
    let first = format!("first_{}-", "a".repeat(30));
    let second = format!("second_{}", "a".repeat(20));
    let original = format!("{first}{second}");
    let mut env = HashMap::from([
        ("FIRST_TOKEN".to_string(), first.clone()),
        ("SECOND_TOKEN".to_string(), second.clone()),
        ("BUNDLE".to_string(), original.clone()),
    ]);

    broker.virtualize_child_env(&mut env);
    assert_ne!(env["FIRST_TOKEN"], first);
    assert_ne!(env["SECOND_TOKEN"], second);
    assert!(env["FIRST_TOKEN"].ends_with('x'));

    let expected = format!("{}{}", env["FIRST_TOKEN"], env["SECOND_TOKEN"]);
    let mut text = original.clone();
    assert!(broker.virtualize_text(&mut text, &env));
    assert_eq!((&env["BUNDLE"], &text), (&expected, &expected));

    let mut snapshot = format!("export BUNDLE='{original}'\n");
    assert!(broker.virtualize_text(&mut snapshot, &env));
    assert_eq!(snapshot, format!("export BUNDLE='{expected}'\n"));
    assert!(broker.restore_text(&mut snapshot));
    assert_eq!(snapshot, format!("export BUNDLE='{original}'\n"));
    assert!(broker.provider_sources_allowed(&expected, "", &env, |_| true));
    for denied in ["FIRST_TOKEN", "SECOND_TOKEN"] {
        assert!(!broker.provider_sources_allowed(&expected, "", &env, |key| key != denied));
    }

    let mut boundary_control = format!("x{second}");
    assert!(broker.virtualize_text(&mut boundary_control, &env));
    assert_eq!(boundary_control, format!("x{second}"));
    let mut dummy_control = format!("x{}", env["SECOND_TOKEN"]);
    assert!(!broker.restore_text(&mut dummy_control));
    assert_eq!(dummy_control, format!("x{}", env["SECOND_TOKEN"]));

    env.remove("FIRST_TOKEN");
    env.remove("SECOND_TOKEN");
    broker.virtualize_child_env_for_environment(&mut env, Some("child"));
    assert_eq!(env["BUNDLE"], expected);
    assert_eq!(
        brokered_credential_marker_env_keys(&env),
        vec!["BUNDLE", "FIRST_TOKEN", "SECOND_TOKEN"]
    );
    assert_eq!(brokered_credential_value_env_keys(&env), vec!["BUNDLE"]);
    assert!(broker.child_alias_matches("BUNDLE", &expected, &expected, /*environment_id*/ None));
    let mut restored = env.clone();
    restored.insert("UNOBSERVED".to_string(), expected.clone());
    broker.restore_and_disable_child_env(&mut restored, &mut []);
    assert_eq!(
        restored,
        HashMap::from([
            ("BUNDLE".to_string(), original),
            ("UNOBSERVED".to_string(), expected),
        ])
    );
}

#[test]
fn adjacent_aliases_survive_rebinding_to_existing_environment() {
    for retain_sources in [false, true] {
        for target in [None, Some("child")] {
            let broker = broker_for(CredentialProviderConfig {
                env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
                patterns: vec![
                    r"^(?:first_a{30}-|first_[b-z]{30}x)$".to_string(),
                    r"\bsecond_[a-z]{20}\b".to_string(),
                ],
                url_prefixes: vec!["https://provider.example/v1".to_string()],
                ..CredentialProviderConfig::default()
            });
            let first = format!("first_{}-", "a".repeat(30));
            let second = format!("second_{}", "a".repeat(20));
            let original = format!("{first}{second}");
            let mut parent = HashMap::from([
                ("FIRST_TOKEN".to_string(), first),
                ("SECOND_TOKEN".to_string(), second),
                ("BUNDLE".to_string(), original.clone()),
            ]);
            let mut expected = parent.clone();
            let mut child = parent.clone();
            child.remove("BUNDLE");
            broker.virtualize_child_env_for_environment(&mut parent, Some("parent"));
            broker.virtualize_child_env_for_environment(&mut child, target);
            assert_ne!(parent["FIRST_TOKEN"], child["FIRST_TOKEN"]);
            if !retain_sources {
                for key in ["FIRST_TOKEN", "SECOND_TOKEN"] {
                    parent.remove(key);
                    expected.remove(key);
                }
            }
            broker.virtualize_child_env_for_environment(&mut parent, target);
            assert_eq!(
                parent["BUNDLE"],
                format!("{}{}", child["FIRST_TOKEN"], child["SECOND_TOKEN"])
            );
            assert_eq!(
                brokered_credential_marker_env_keys(&parent),
                vec!["BUNDLE", "FIRST_TOKEN", "SECOND_TOKEN"]
            );
            let mut text = parent["BUNDLE"].clone();
            assert!(broker.restore_text(&mut text));
            assert_eq!(text, original);
            broker.restore_and_disable_child_env(&mut parent, &mut []);
            assert_eq!(parent, expected);
        }
    }
}

#[test]
fn generated_alias_spans_recognize_overlapping_dummy_candidates() {
    let broker = broker_for(CredentialProviderConfig {
        // Register the short dummy before the longer dummy containing its bytes.
        env: vec!["SECOND_TOKEN".to_string(), "FIRST_TOKEN".to_string()],
        patterns: vec![
            r"^(?:first_a{30}-|first_b{31})$".to_string(),
            r"\b(?:a{16}|b{16})\b".to_string(),
        ],
        url_prefixes: vec!["https://provider.example/v1".to_string()],
        ..CredentialProviderConfig::default()
    });
    let first = format!("first_{}-", "a".repeat(30));
    let second = "a".repeat(16);
    let original = format!("{first}{second}");
    let mut env = HashMap::from([
        ("FIRST_TOKEN".to_string(), first),
        ("SECOND_TOKEN".to_string(), second),
        ("BUNDLE".to_string(), original.clone()),
    ]);
    broker.virtualize_child_env(&mut env);
    assert_eq!(env["BUNDLE"], format!("first_{}", "b".repeat(47)));
    let state = broker.read_state();
    let second = state
        .credentials
        .iter()
        .find(|credential| credential.env_var == "SECOND_TOKEN")
        .unwrap();
    assert_eq!(second.generated_dummy_ranges(&env["BUNDLE"]), vec![37..53]);
    drop(state);
    assert!(!broker.provider_sources_allowed(&env["BUNDLE"], "", &env, |key| key == "FIRST_TOKEN"));
    let mut repeated = format!("\u{03bb}{};{}", env["BUNDLE"], env["BUNDLE"]);
    assert!(broker.restore_text(&mut repeated));
    assert_eq!(repeated, format!("\u{03bb}{original};{original}"));
    env.remove("FIRST_TOKEN");
    env.remove("SECOND_TOKEN");
    broker.virtualize_child_env(&mut env);
    assert_eq!(
        brokered_credential_marker_env_keys(&env),
        vec!["BUNDLE", "FIRST_TOKEN", "SECOND_TOKEN"]
    );
    broker.restore_and_disable_child_env(&mut env, &mut []);
    assert_eq!(env, HashMap::from([("BUNDLE".to_string(), original)]));
}

#[test]
fn adjacent_dummy_restoration_keeps_original_boundaries() {
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
        patterns: vec![
            r"^(?:first_a{30}x|first_[b-z]{30}-)$".to_string(),
            r"\bsecond_[a-z]{20}\b".to_string(),
        ],
        url_prefixes: vec!["https://provider.example/v1".to_string()],
        ..CredentialProviderConfig::default()
    });
    let first = format!("first_{}x", "a".repeat(30));
    let second = format!("second_{}", "a".repeat(20));
    let mut env = HashMap::from([
        ("FIRST_TOKEN".to_string(), first.clone()),
        ("SECOND_TOKEN".to_string(), second.clone()),
    ]);
    broker.virtualize_child_env(&mut env);
    assert!(env["FIRST_TOKEN"].ends_with('-'));
    let mut text = format!("{}{}", env["FIRST_TOKEN"], env["SECOND_TOKEN"]);
    env.insert("BUNDLE".to_string(), text.clone());
    broker.virtualize_child_env(&mut env);
    let mut partial = env.clone();
    broker
        .read_state()
        .restore_child_env(&mut partial, |credential| {
            credential.env_var == "FIRST_TOKEN"
        });
    let mut partial_text = partial["BUNDLE"].clone();
    assert_eq!(partial_text, format!("{first}{}", env["SECOND_TOKEN"]));
    assert!(
        !broker.provider_sources_allowed(&partial_text, "", &partial, |key| key == "FIRST_TOKEN")
    );
    assert!(broker.restore_text(&mut partial_text));
    assert_eq!(partial_text, format!("{first}{second}"));
    assert!(broker.restore_text(&mut text));
    assert_eq!(text, format!("{first}{second}"));
    broker.restore_and_disable_child_env(&mut env, &mut []);
    assert_eq!(
        env,
        HashMap::from([
            ("FIRST_TOKEN".to_string(), first.clone()),
            ("SECOND_TOKEN".to_string(), second.clone()),
            ("BUNDLE".to_string(), format!("{first}{second}"))
        ])
    );
}

#[test]
fn local_proxy_bypass_preserves_credentials_and_aliases_across_reload() {
    let token = "vendor_abcdefghijklmnopqrstuvwx";
    let github = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";
    for (destination, bypassed) in [
        ("http://localhost:1234/v1", true),
        ("http://127.0.0.1:1234/v1", true),
        ("http://[::1]:1234/v1", true),
        ("https://10.1.2.3/v1", true),
        ("https://172.16.2.3/v1", true),
        ("https://192.168.2.3/v1", true),
        ("https://api.localhost/v1", true),
        ("https://127.0.0.2/v1", false),
        ("https://172.32.2.3/v1", false),
        ("https://api.vendor.example/v1", false),
    ] {
        let broker = CredentialBroker::new(/*enabled*/ true);
        let mut config = NetworkProxyConfig {
            credential_broker: true,
            credential_providers: BTreeMap::from([(
                "vendor".to_string(),
                CredentialProviderConfig {
                    env: vec!["VENDOR_TOKEN".to_string()],
                    patterns: vec!["^vendor_[a-z]{24}$".to_string()],
                    url_prefixes: vec!["https://public.vendor.example/v1".to_string()],
                    url_prefix_from_env: Some("VENDOR_URL".to_string()),
                    ..CredentialProviderConfig::default()
                },
            )]),
            ..NetworkProxyConfig::default()
        };
        broker.configure(&config);
        let mut env = HashMap::from([
            ("VENDOR_TOKEN".to_string(), token.to_string()),
            ("VENDOR_URL".to_string(), destination.to_string()),
            ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
            ("GH_TOKEN".to_string(), github.to_string()),
        ]);
        broker.virtualize_child_env(&mut env);
        let dummy = env["VENDOR_TOKEN"].clone();
        let github_dummy = env["GH_TOKEN"].clone();
        assert_ne!(dummy, token);
        assert_ne!(github_dummy, github);

        config.allow_local_binding = Some(true);
        let revision = broker.config_revision();
        broker.configure(&config);
        assert_eq!(broker.config_revision(), revision + 1);
        for _ in 0..2 {
            broker.virtualize_child_env(&mut env);
            let expected = if bypassed { token } else { &dummy };
            assert_eq!(
                (&env["VENDOR_TOKEN"], &env["AUTH_HEADER"], &env["GH_TOKEN"]),
                (
                    &expected.to_string(),
                    &format!("Bearer {expected}"),
                    &github_dummy
                ),
                "{destination}"
            );
            assert_eq!(
                brokered_credential_value_env_keys(&env),
                if bypassed {
                    vec!["GH_TOKEN"]
                } else {
                    vec!["AUTH_HEADER", "GH_TOKEN", "VENDOR_TOKEN"]
                }
            );
        }
        config.allow_local_binding = Some(false);
        let mut snapshot_env = env.clone();
        broker.virtualize_snapshot_env(&mut snapshot_env, /*environment_id*/ None);
        assert_eq!(snapshot_env["VENDOR_TOKEN"], dummy);
        assert_eq!(snapshot_env["AUTH_HEADER"], format!("Bearer {dummy}"));
        broker.configure(&config);
        broker.virtualize_child_env(&mut env);
        assert_eq!(env["VENDOR_TOKEN"], dummy);
        assert_eq!(env["AUTH_HEADER"], format!("Bearer {dummy}"));
    }
}

#[test]
fn child_alias_identity_survives_scoped_dummies_and_partial_direct_restoration() {
    let local = "local_abcdefghijklmnopqrstuvwx";
    let remote = "ghp_abcdefghijklmnopqrstuvwxyz0123456789";
    for allow_local_binding in [false, true] {
        let broker = CredentialBroker::new(/*enabled*/ true);
        broker.configure(&NetworkProxyConfig {
            credential_broker: true,
            allow_local_binding: Some(allow_local_binding),
            credential_providers: BTreeMap::from([(
                "local".to_string(),
                CredentialProviderConfig {
                    env: vec!["LOCAL_TOKEN".to_string()],
                    patterns: vec!["^local_[a-z]{24}$".to_string()],
                    url_prefixes: vec!["http://127.0.0.1:1234".to_string()],
                    ..CredentialProviderConfig::default()
                },
            )]),
            ..NetworkProxyConfig::default()
        });
        let real_alias = format!("Local {local}; Remote {remote}");
        let mut env = HashMap::from([
            ("LOCAL_TOKEN".to_string(), local.to_string()),
            ("GH_TOKEN".to_string(), remote.to_string()),
            ("AUTH_HEADER".to_string(), real_alias.clone()),
        ]);
        let mut snapshot = env.clone();
        broker.virtualize_snapshot_env(&mut snapshot, Some("snapshot"));
        let snapshot_alias = snapshot["AUTH_HEADER"].clone();
        broker.virtualize_child_env_for_environment(&mut env, Some("child"));
        env.remove("LOCAL_TOKEN");
        env.remove("GH_TOKEN");
        assert_eq!(env["AUTH_HEADER"].contains(local), allow_local_binding);
        assert!(!env["AUTH_HEADER"].contains(remote));
        assert!(broker.child_alias_matches(
            "AUTH_HEADER",
            &env["AUTH_HEADER"],
            &snapshot_alias,
            Some("child")
        ));
        assert!(!broker.child_alias_matches(
            "AUTH_HEADER",
            &real_alias,
            &snapshot_alias,
            Some("child")
        ));
        assert!(!broker.child_alias_matches(
            "AUTH_HEADER",
            &format!("{} altered", env["AUTH_HEADER"]),
            &snapshot_alias,
            Some("child")
        ));
        assert!(!broker.child_alias_matches(
            "OTHER_HEADER",
            &env["AUTH_HEADER"],
            &snapshot_alias,
            Some("child")
        ));
    }
}

#[test]
fn local_proxy_bypass_is_scoped_for_inherited_credentials_and_aliases() {
    let token = "vendor_abcdefghijklmnopqrstuvwx";
    for parent_is_local in [false, true] {
        for retain_source in [false, true] {
            let broker = CredentialBroker::new(/*enabled*/ true);
            broker.configure(&NetworkProxyConfig {
                credential_broker: true,
                allow_local_binding: Some(true),
                credential_providers: BTreeMap::from([(
                    "vendor".to_string(),
                    CredentialProviderConfig {
                        env: vec!["VENDOR_TOKEN".to_string()],
                        patterns: vec!["^vendor_[a-z]{24}$".to_string()],
                        url_prefix_from_env: Some("VENDOR_URL".to_string()),
                        ..CredentialProviderConfig::default()
                    },
                )]),
                ..NetworkProxyConfig::default()
            });
            let local = "http://127.0.0.1:1234/v1";
            let public = "https://api.vendor.example/v1";
            let mut snapshot = HashMap::from([
                ("VENDOR_TOKEN".to_string(), token.to_string()),
                (
                    "VENDOR_URL".to_string(),
                    if parent_is_local { local } else { public }.to_string(),
                ),
                ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
            ]);
            broker.virtualize_snapshot_env(&mut snapshot, Some("parent"));
            let dummy = snapshot["VENDOR_TOKEN"].clone();
            let snapshot_alias = snapshot["AUTH_HEADER"].clone();
            let mut child = snapshot.clone();
            child.insert(
                "VENDOR_URL".to_string(),
                if parent_is_local { public } else { local }.to_string(),
            );
            if !retain_source {
                child.remove("VENDOR_TOKEN");
            }
            for (id, env, bypasses) in [
                ("child", &mut child, !parent_is_local),
                ("parent", &mut snapshot, parent_is_local),
            ] {
                broker.virtualize_child_env_for_environment(env, Some(id));
                let expected = if bypasses { token } else { &dummy };
                assert_eq!(
                    env.get("VENDOR_TOKEN").map(String::as_str),
                    (retain_source || id == "parent").then_some(expected)
                );
                assert_eq!(env["AUTH_HEADER"], format!("Bearer {expected}"));
                assert!(broker.child_alias_matches(
                    "AUTH_HEADER",
                    &env["AUTH_HEADER"],
                    &snapshot_alias,
                    Some(id)
                ));
                if !bypasses {
                    assert!(!broker.child_alias_matches(
                        "AUTH_HEADER",
                        &format!("Bearer {token}"),
                        &snapshot_alias,
                        Some(id)
                    ));
                }
            }
        }
    }
}

#[test]
fn configured_provider_virtualizes_credentials_aliases_and_snapshots() {
    let token = "stripe_live_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["STRIPE_API_KEY".to_string()],
        patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
        url_prefixes: vec!["api.stripe.com".to_string(), "*.stripe.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([
        ("STRIPE_API_KEY".to_string(), token.to_string()),
        ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
    ]);

    broker.virtualize_child_env(&mut env);

    let dummy = &env["STRIPE_API_KEY"];
    assert_ne!(dummy, token);
    assert!(
        regex::Regex::new("^stripe_live_[a-z]{24}$")
            .expect("valid credential pattern")
            .is_match(dummy)
    );
    assert_eq!(env["AUTH_HEADER"], format!("Bearer {dummy}"));
    assert_eq!(
        brokered_credential_value_env_keys(&env),
        vec!["AUTH_HEADER", "STRIPE_API_KEY"]
    );
    assert_eq!(
        broker.environment(&env).credential_keys,
        vec!["STRIPE_API_KEY".to_string()]
    );
    let mut snapshot = format!("token={token}");
    assert!(broker.virtualize_text(&mut snapshot, &env));
    assert_eq!(snapshot, format!("token={dummy}"));
    let mut unknown = "stripe_live_yyyyyyyyyyyyyyyyyyyyyyyy".to_string();
    assert!(!broker.virtualize_text(&mut unknown, &env));
    assert!(unknown.is_empty());
    assert!(broker.host_requires_mitm("api.stripe.com", /*port*/ 443));
    assert!(broker.host_requires_mitm("billing.stripe.example", /*port*/ 443));
    assert!(!broker.host_requires_mitm("stripe.example", /*port*/ 443));
    assert!(!broker.host_requires_mitm("attacker.example", /*port*/ 443));
    let dummy_header = format!("Bearer {dummy}");
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&dummy_header).expect("valid dummy authentication"),
    );
    broker.inject_request_headers("https://attacker.example/", &mut headers);
    assert_eq!(
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok()),
        Some(dummy_header.as_str())
    );

    let mut unmanaged_env = env.clone();
    crate::strip_managed_proxy_env(&mut unmanaged_env);
    assert!(!unmanaged_env.contains_key("STRIPE_API_KEY"));
    env.remove("STRIPE_API_KEY");
    broker.virtualize_child_env(&mut env);
    assert_eq!(
        brokered_credential_marker_env_keys(&env),
        vec!["AUTH_HEADER", "STRIPE_API_KEY"]
    );
    assert_eq!(
        brokered_credential_value_env_keys(&env),
        vec!["AUTH_HEADER"]
    );
}

#[test]
fn configured_provider_discovers_credentials_without_canonical_variables() {
    let token = "stripe_live_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["STRIPE_API_KEY".to_string()],
        patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
        url_prefixes: vec!["api.stripe.com".to_string()],
        ..CredentialProviderConfig::default()
    });
    let authorization_header = format!("Bearer {token}");
    let mut env = HashMap::from([("AUTH_HEADER".to_string(), authorization_header.clone())]);

    broker.virtualize_child_env(&mut env);

    assert!(!env.contains_key("STRIPE_API_KEY"));
    let dummy_header = &env["AUTH_HEADER"];
    assert_ne!(dummy_header, &authorization_header);
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(dummy_header).expect("valid dummy authentication"),
    );
    broker.inject_request_headers("https://api.stripe.com/", &mut headers);
    assert_eq!(
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok()),
        Some(authorization_header.as_str())
    );
    let mut snapshot = format!("export AUTH_HEADER='{authorization_header}'");
    assert!(broker.virtualize_text(&mut snapshot, &env));
    assert_eq!(snapshot, format!("export AUTH_HEADER='{dummy_header}'"));

    broker.restore_child_env(&mut env, &mut []);
    assert_eq!(env["AUTH_HEADER"], authorization_header);
    assert!(!env.contains_key("STRIPE_API_KEY"));
}

#[test]
fn configured_provider_uses_private_destination_context() {
    let token = "pin_abcdefgh";
    let destination = "https://api.vendor.example/v2";
    let mut config = NetworkProxyConfig {
        credential_broker: true,
        credential_providers: BTreeMap::from([(
            "vendor".to_string(),
            CredentialProviderConfig {
                env: vec!["VENDOR_PASSWORD".to_string()],
                patterns: vec!["pin_[a-z]{8}".to_string()],
                url_prefix_from_env: Some("VENDOR_HOST".to_string()),
                ..CredentialProviderConfig::default()
            },
        )]),
        ..NetworkProxyConfig::default()
    };
    config.configure_credential_broker_environment(&HashMap::from([
        ("VENDOR_HOST".to_string(), destination.to_string()),
        ("UNRELATED_SECRET".to_string(), token.to_string()),
    ]));
    assert!(!format!("{config:?}").contains(destination));
    assert!(
        !serde_json::to_string(&config)
            .unwrap()
            .contains(destination)
    );
    let broker = CredentialBroker::new(/*enabled*/ true);
    broker.configure(&config);
    let mut env = HashMap::from([
        ("VENDOR_PASSWORD".to_string(), token.to_string()),
        ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
    ]);

    for environment_id in [None, Some("child")] {
        broker.virtualize_child_env_for_environment(&mut env, environment_id);
        assert!(!env.contains_key("VENDOR_HOST"));
        assert!(!env.contains_key("UNRELATED_SECRET"));
        assert_ne!(env["AUTH_HEADER"], format!("Bearer {token}"));
        let dummy_header = env["AUTH_HEADER"].clone();
        env.remove("VENDOR_PASSWORD");
        broker.virtualize_child_env_for_environment(&mut env, environment_id);
        assert_eq!(env["AUTH_HEADER"], dummy_header);
        let mut snapshot = format!("export AUTH_HEADER='Bearer {token}'");
        assert!(broker.virtualize_text(&mut snapshot, &env));
        assert_eq!(snapshot, format!("export AUTH_HEADER='{dummy_header}'"));
        for host in [destination, "https://other.example/v2"] {
            let mut headers = HeaderMap::new();
            headers.insert(AUTHORIZATION, HeaderValue::from_str(&dummy_header).unwrap());
            broker.inject_request_headers_for_environment(host, &mut headers, environment_id);
            assert_eq!(
                headers[AUTHORIZATION],
                if host == destination {
                    format!("Bearer {token}")
                } else {
                    dummy_header.clone()
                }
            );
        }
    }

    for host in ["https://override.example/v3", "", "not a valid destination"] {
        let mut env = HashMap::from([
            ("VENDOR_PASSWORD".to_string(), token.to_string()),
            ("VENDOR_HOST".to_string(), host.to_string()),
        ]);
        broker.virtualize_child_env(&mut env);
        assert_eq!(env["VENDOR_HOST"], host);
        assert_eq!(
            env["VENDOR_PASSWORD"] == token,
            !host.starts_with("https://")
        );
        let dummy_header = format!("Bearer {}", env["VENDOR_PASSWORD"]);
        let mut headers = HeaderMap::new();
        headers.insert(AUTHORIZATION, HeaderValue::from_str(&dummy_header).unwrap());
        broker.inject_request_headers(destination, &mut headers);
        assert_eq!(headers[AUTHORIZATION], format!("Bearer {token}"));
        if host.starts_with("https://") {
            headers.insert(AUTHORIZATION, HeaderValue::from_str(&dummy_header).unwrap());
            broker.inject_request_headers(host, &mut headers);
            assert_eq!(headers[AUTHORIZATION], format!("Bearer {token}"));
        }
    }
}

#[test]
fn configured_provider_preserves_credentials_without_a_resolved_destination() {
    let token = "stripe_live_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["STRIPE_API_KEY".to_string()],
        patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
        url_prefix_from_env: Some("STRIPE_HOST".to_string()),
        ..CredentialProviderConfig::default()
    });
    let mut bound_env = HashMap::from([
        ("STRIPE_API_KEY".to_string(), token.to_string()),
        ("STRIPE_HOST".to_string(), "api.stripe.com".to_string()),
    ]);
    broker.virtualize_child_env(&mut bound_env);
    assert_ne!(bound_env["STRIPE_API_KEY"], token);

    let mut env = HashMap::from([("STRIPE_API_KEY".to_string(), token.to_string())]);

    broker.virtualize_child_env(&mut env);

    assert_eq!(env["STRIPE_API_KEY"], token);
    assert!(broker.environment(&env).credential_keys.is_empty());
}

#[test]
fn configured_provider_does_not_guess_ambiguous_alias_destinations() {
    for (token, pattern, overlaps_builtin) in [
        (
            "shared_abcdefghijklmnopqrstuvwxyz",
            "^shared_[a-z]{26}$",
            false,
        ),
        (
            "sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
            "^sk-proj-[A-Za-z0-9]+$",
            true,
        ),
    ] {
        let first = CredentialProviderConfig {
            env: vec!["FIRST_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["first.example".to_string()],
            ..CredentialProviderConfig::default()
        };
        let mut providers = BTreeMap::from([("first".to_string(), first.clone())]);
        if !overlaps_builtin {
            providers.insert(
                "second".to_string(),
                CredentialProviderConfig {
                    env: vec!["SECOND_TOKEN".to_string()],
                    url_prefixes: vec!["second.example".to_string()],
                    ..first
                },
            );
        }
        let broker = CredentialBroker::new(/*enabled*/ true);
        broker.configure(&NetworkProxyConfig {
            credential_broker: true,
            credential_providers: providers,
            ..NetworkProxyConfig::default()
        });
        let authorization_header = format!("Bearer {token}");
        let mut env = HashMap::from([("AUTH_HEADER".to_string(), authorization_header.clone())]);

        broker.virtualize_child_env(&mut env);

        assert_eq!(env["AUTH_HEADER"], authorization_header);
        assert!(!broker.host_requires_mitm("first.example", /*port*/ 443));
        assert!(!broker.host_requires_mitm("second.example", /*port*/ 443));
        if overlaps_builtin {
            assert!(!broker.host_requires_mitm("api.openai.com", /*port*/ 443));
        }

        env.insert("FIRST_TOKEN".to_string(), token.to_string());
        broker.virtualize_child_env(&mut env);
        assert_ne!(env["AUTH_HEADER"], authorization_header);
        let mut headers = HeaderMap::new();
        headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(&env["AUTH_HEADER"]).expect("valid dummy authentication"),
        );
        broker.inject_request_headers("https://first.example/", &mut headers);
        assert_eq!(
            headers
                .get(AUTHORIZATION)
                .and_then(|value| value.to_str().ok()),
            Some(authorization_header.as_str())
        );
    }
}

#[test]
fn configured_owner_keeps_prefixed_builtin_shaped_aliases_scoped() {
    let aliases = [
        ("COPIED", "x", ""),
        ("SUFFIXED", "", "_prod"),
        ("WRAPPED", "backup_", "-staging"),
        (
            "LONG_SUFFIX",
            "",
            "_production_shared_service_account_westus2",
        ),
    ];
    for (pattern, token_length, dummy_prefix) in [
        (r"\bsk-proj-[a-z]{64}\b", 64, Some("sk-proj-")),
        // The fixed real branch forces an independently generated vendor-shaped dummy.
        (
            r"\b(?:sk-proj-a{64}|vendor_[a-z]{64})\b",
            64,
            Some("vendor_"),
        ),
        // With no distinct long alternative, registration must remain fail-open.
        (r"\b(?:sk-proj-a{64}|pin)\b", 64, None),
        (r"\b(?:sk-proj-[a-z]{64}|pin)\b", 64, Some("sk-proj-")),
        (r"^sk-proj-[a-z]{7}$", 7, Some("sk-proj-")),
    ] {
        let token = format!("sk-proj-{}", "a".repeat(token_length));
        for (environment_id, retain_source) in [
            (None, true),
            (Some("local"), true),
            (None, false),
            (Some("local"), false),
        ] {
            for (static_destination, destination) in [
                (None, Some("https://configured.example/v1")),
                (Some("https://configured.example/v1"), None),
                (None, None),
            ] {
                let broker = broker_for(CredentialProviderConfig {
                    env: vec!["VENDOR_KEY".to_string()],
                    patterns: vec![pattern.to_string()],
                    url_prefixes: static_destination.into_iter().map(str::to_string).collect(),
                    url_prefix_from_env: Some("VENDOR_URL".to_string()),
                    ..CredentialProviderConfig::default()
                });
                let mut env = HashMap::from([("VENDOR_KEY".to_string(), token.clone())]);
                env.extend(aliases.map(|(key, prefix, suffix)| {
                    (key.to_string(), format!("{prefix}{token}{suffix}"))
                }));
                if let Some(destination) = destination {
                    env.insert("VENDOR_URL".to_string(), destination.to_string());
                }
                if !retain_source {
                    let parent_env = env.clone();
                    env.remove("VENDOR_KEY");
                    broker.discover_parent_credentials_for_environment(
                        &parent_env,
                        &env,
                        environment_id,
                    );
                }
                let mut original_env = env.clone();

                broker.virtualize_child_env_for_environment(&mut env, environment_id);

                // Arrive after registration so environment collision checks cannot mask a short dummy.
                let mut ordinary = "spinning".to_string();
                assert!(!broker.restore_text(&mut ordinary));
                assert_eq!(ordinary, "spinning");
                env.insert("UNRELATED".to_string(), ordinary.clone());
                original_env.insert("UNRELATED".to_string(), ordinary);
                let brokered = (static_destination.is_some() || destination.is_some())
                    && dummy_prefix.is_some();
                let value = env["COPIED"].strip_prefix('x').unwrap();
                assert_eq!(
                    env.get("VENDOR_KEY").map(String::as_str),
                    retain_source.then_some(value)
                );
                assert_eq!(value != token, brokered);
                assert!(
                    !broker
                        .host_protocols_for_environment(
                            "api.openai.com",
                            /*port*/ 443,
                            environment_id,
                        )
                        .tls
                );
                let headers_for = |value: &str| {
                    HeaderMap::from_iter([(
                        AUTHORIZATION,
                        HeaderValue::from_str(&format!("Bearer {value}")).unwrap(),
                    )])
                };
                for target in [
                    "https://api.openai.com/v1/models",
                    "https://api.github.com/v1/models",
                    "https://configured.example/v2/models",
                    "https://configured.example/v1/models",
                ] {
                    let mut headers = headers_for(value);
                    broker.inject_request_headers_for_environment(
                        target,
                        &mut headers,
                        environment_id,
                    );
                    let expected = if brokered && target == "https://configured.example/v1/models" {
                        &token
                    } else {
                        value
                    };
                    assert_eq!(headers, headers_for(expected));
                }
                let mut alias_only = env.clone();
                alias_only.remove("VENDOR_KEY");
                broker.virtualize_child_env_for_environment(&mut alias_only, environment_id);
                for (key, prefix, suffix) in aliases {
                    assert_eq!(env[key], format!("{prefix}{value}{suffix}"));
                    assert_eq!(alias_only[key], env[key]);
                    assert!(broker.provider_sources_allowed(
                        &original_env[key],
                        &env[key],
                        &original_env,
                        |source| source == "VENDOR_KEY"
                    ));
                    assert!(!broker.provider_sources_allowed(
                        &original_env[key],
                        &env[key],
                        &original_env,
                        |source| source == "OPENAI_API_KEY"
                    ));
                    let mut snapshot_alias = original_env[key].clone();
                    if brokered || token.len() >= super::MIN_EMBEDDED_CREDENTIAL_LENGTH {
                        assert_eq!(
                            broker.virtualize_text(&mut snapshot_alias, &alias_only),
                            brokered,
                        );
                        assert!(!snapshot_alias.contains(&token));
                    }
                    if brokered {
                        assert!(value.starts_with(dummy_prefix.unwrap()));
                        assert!(
                            value.len() >= token.len().min(super::MIN_EMBEDDED_CREDENTIAL_LENGTH)
                        );
                        assert!(
                            brokered_credential_marker_env_keys(&alias_only)
                                .contains(&key.to_string())
                        );
                        assert_eq!(snapshot_alias, env[key]);
                        assert!(
                            broker
                                .environment_for_text(&snapshot_alias, &env)
                                .credential_keys
                                .contains(&"VENDOR_KEY".to_string())
                        );
                        assert!(broker.source_matches_text(
                            "VENDOR_KEY",
                            &token,
                            &original_env[key]
                        ));
                        assert!(broker.child_alias_matches(
                            key,
                            &env[key],
                            &snapshot_alias,
                            environment_id,
                        ));
                        assert!(broker.restore_text(&mut snapshot_alias));
                        assert_eq!(snapshot_alias, original_env[key]);
                    }
                }
                broker.restore_and_disable_child_env(&mut env, &mut []);
                assert_eq!(env, original_env);
            }
        }
    }
}

#[test]
fn known_credential_spans_preserve_overlaps_and_uncovered_adjacent_credentials() {
    let short = format!("sk-proj-{}", "a".repeat(64));
    let long = format!("{short}bbbbbbbb");
    let known = format!(":known_{}", "b".repeat(24));
    let github = "ghp_spinningabcdefghijklmnopqrstuvwxyz0123456789";
    for (separator, extra, extra_pattern) in [
        ("", "extra_abcdefghijklmnopqrstuvwx", "^extra_[a-z]{24}$"),
        ("_", "extra_abcdefghijklmnopqrstuvwx", "^extra_[a-z]{24}$"),
        ("-", "extra_abcdefghijklmnopqrstuvwx", "^extra_[a-z]{24}$"),
        ("", "extra_abcdefghijklmnopqrstuvwx_", "^extra_[a-z]{24}_$"),
        ("", "extra_abcdefghijklmnopqrstuvwx-", "^extra_[a-z]{24}-$"),
    ] {
        let broker = CredentialBroker::new(/*enabled*/ true);
        broker.configure(&NetworkProxyConfig {
            credential_broker: true,
            credential_providers: BTreeMap::from([
                (
                    "vendor".to_string(),
                    CredentialProviderConfig {
                        env: vec![
                            "SHORT_KEY".to_string(),
                            "LONG_KEY".to_string(),
                            "KNOWN_KEY".to_string(),
                            "PIN_KEY".to_string(),
                        ],
                        patterns: vec![
                            r"\bsk-proj-[ab]{64,72}\b".to_string(),
                            "^:known_[a-z]{24}$".to_string(),
                            r"\bpin\b".to_string(),
                        ],
                        url_prefixes: vec!["https://vendor.example/v1".to_string()],
                        ..CredentialProviderConfig::default()
                    },
                ),
                (
                    "extra".to_string(),
                    CredentialProviderConfig {
                        env: vec!["EXTRA_KEY".to_string()],
                        // The broad Basic-capable alternative must not discover masked known values.
                        patterns: vec![extra_pattern.to_string(), "(?s)^.{80,}$".to_string()],
                        url_prefixes: vec!["https://extra.example/v1".to_string()],
                        auth: vec![CredentialAuthMethod::Bearer, CredentialAuthMethod::Basic],
                        ..CredentialProviderConfig::default()
                    },
                ),
            ]),
            ..NetworkProxyConfig::default()
        });
        let original = HashMap::from([
            ("SHORT_KEY".to_string(), short.clone()),
            ("LONG_KEY".to_string(), long.clone()),
            ("KNOWN_KEY".to_string(), known.clone()),
            ("PIN_KEY".to_string(), "pin".to_string()),
            // This observed short generic owner must not hide the distinct full GitHub token.
            ("GH_TOKEN".to_string(), "ghp_".to_string()),
            (
                "BUNDLE".to_string(),
                format!("{github}{separator}{long}{separator}{extra}{known}"),
            ),
            ("OVERLAP".to_string(), format!("{long}_{short}")),
        ]);
        assert!(!broker.provider_sources_allowed(
            &format!("{extra}{known}"),
            "",
            &original,
            |source| source == "KNOWN_KEY"
        ));
        let mut env = original.clone();
        broker.virtualize_child_env(&mut env);
        let state = broker.read_state();
        assert_eq!(state.credentials.len(), 6);
        assert!(
            state
                .credentials
                .iter()
                .all(|credential| !credential.real_value.contains('\0'))
        );
        let dummy = |real| {
            state
                .credentials
                .iter()
                .find(|credential| credential.real_value == real)
                .unwrap_or_else(|| {
                    panic!("missing registration for {real}, separator {separator:?}")
                })
                .dummy_value
                .clone()
        };
        let github_dummy = dummy(github);
        let extra_dummy = dummy(extra);
        assert_eq!(
            env["BUNDLE"],
            format!(
                "{github_dummy}{separator}{}{separator}{extra_dummy}{}",
                env["LONG_KEY"], env["KNOWN_KEY"]
            )
        );
        assert_eq!(
            env["OVERLAP"],
            format!("{}_{}", env["LONG_KEY"], env["SHORT_KEY"])
        );
        drop(state);
        for (key, allowed) in [("LONG_KEY", true), ("SHORT_KEY", false)] {
            assert_eq!(
                broker.provider_sources_allowed(
                    &long,
                    &env["LONG_KEY"],
                    &original,
                    |source| source == key
                ),
                allowed
            );
        }
        assert!(!broker.provider_sources_allowed(
            &original["BUNDLE"],
            &env["BUNDLE"],
            &original,
            |source| source == "LONG_KEY"
        ));
        assert!(broker.provider_sources_allowed(
            &original["BUNDLE"],
            &env["BUNDLE"],
            &original,
            |_| true
        ));
        for (real, dummy, destination) in [
            (github, &github_dummy, "https://api.github.com/v1"),
            (extra, &extra_dummy, "https://extra.example/v1"),
        ] {
            let mut headers = HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {dummy}")).unwrap(),
            )]);
            broker.inject_request_headers(destination, &mut headers);
            assert_eq!(headers[AUTHORIZATION], format!("Bearer {real}"));
        }
        broker.restore_and_disable_child_env(&mut env, &mut []);
        assert_eq!(env, original);
    }
}

#[test]
fn configured_provider_does_not_claim_embedded_builtin_credentials() {
    let github_token = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";
    let openai_token = "sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["COMBINED_TOKEN".to_string()],
        patterns: vec!["^combo_[A-Za-z0-9_-]{80,180}$".to_string()],
        url_prefixes: vec!["combo.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let combined = format!("combo_{github_token}_{openai_token}");
    let mut env = HashMap::from([("AUTH_HEADER".to_string(), combined.clone())]);

    broker.virtualize_child_env(&mut env);

    assert_ne!(env["AUTH_HEADER"], combined);
    assert!(!env["AUTH_HEADER"].contains(github_token));
    assert!(!env["AUTH_HEADER"].contains(openai_token));
    assert!(!broker.host_requires_mitm("combo.example", /*port*/ 443));
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&env["AUTH_HEADER"]).expect("valid dummy authentication"),
    );
    broker.inject_request_headers("https://combo.example/", &mut headers);
    assert_eq!(
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok()),
        Some(env["AUTH_HEADER"].as_str())
    );
}

#[test]
fn configured_discovery_does_not_claim_overlapping_credential_spans() {
    let suffix = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV";
    for token in [format!("sk-{suffix}"), format!("sk-proj-{suffix}{suffix}")] {
        for patterns in [
            vec!["^[A-Za-z0-9]{48}$".to_string()],
            vec![
                "^vendor_[a-z]{24}$".to_string(),
                "^[A-Za-z0-9]{48}$".to_string(),
            ],
        ] {
            let broker = broker_for(CredentialProviderConfig {
                env: vec!["VENDOR_TOKEN".to_string()],
                patterns,
                url_prefixes: vec!["vendor.example".to_string()],
                ..CredentialProviderConfig::default()
            });
            let mut env = HashMap::from([("AUTH_HEADER".to_string(), format!("Bearer {token}"))]);
            broker.virtualize_child_env(&mut env);
            assert!(!broker.host_requires_mitm("vendor.example", /*port*/ 443));
            assert!(broker.read_state().credentials.iter().all(|credential| {
                !matches!(
                    credential.provider,
                    BrokeredCredentialProvider::Configured(_)
                )
            }));

            // An explicit canonical source still identifies the provider unambiguously.
            env.insert("VENDOR_TOKEN".to_string(), suffix.to_string());
            broker.virtualize_child_env(&mut env);
            let mut headers = HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {}", env["VENDOR_TOKEN"])).unwrap(),
            )]);
            broker.inject_request_headers("https://vendor.example/", &mut headers);
            assert_eq!(headers[AUTHORIZATION], format!("Bearer {suffix}"));
        }
    }

    for (value, outer, inner) in [
        (
            format!("outer_{suffix}"),
            "^outer_[A-Za-z0-9]{48}$",
            "^[A-Za-z0-9]{48}$",
        ),
        (
            "first_aaaa.second_bbbb/cccc".to_string(),
            r"^first_[a-z]{4}\.second_[a-z]{4}$",
            "^second_[a-z]{4}/[a-z]{4}$",
        ),
    ] {
        let broker = CredentialBroker::new(/*enabled*/ true);
        broker.configure(&NetworkProxyConfig {
            credential_broker: true,
            credential_providers: [("outer", outer), ("inner", inner)]
                .into_iter()
                .map(|(id, pattern)| {
                    (
                        id.to_string(),
                        CredentialProviderConfig {
                            env: vec![format!("{}_TOKEN", id.to_uppercase())],
                            patterns: vec![pattern.to_string()],
                            url_prefixes: vec![format!("{id}.example")],
                            ..CredentialProviderConfig::default()
                        },
                    )
                })
                .collect(),
            ..NetworkProxyConfig::default()
        });
        let mut env = HashMap::from([("AUTH_HEADER".to_string(), format!("Bearer {value}"))]);
        broker.virtualize_child_env(&mut env);
        assert!(broker.read_state().credentials.is_empty());
        assert_eq!(env["AUTH_HEADER"], format!("Bearer {value}"));
    }
}

#[test]
fn configured_dummy_does_not_embed_another_provider_credential() {
    let broker = CredentialBroker::new(/*enabled*/ true);
    broker.configure(&NetworkProxyConfig {
        credential_broker: true,
        credential_providers: BTreeMap::from([
            (
                "backup".to_string(),
                CredentialProviderConfig {
                    env: vec!["BACKUP_TOKEN".to_string()],
                    patterns: vec!["^backup_(?:stage|prod)$".to_string()],
                    url_prefixes: vec!["backup.example".to_string()],
                    ..CredentialProviderConfig::default()
                },
            ),
            (
                "tenant".to_string(),
                CredentialProviderConfig {
                    env: vec!["TENANT_TOKEN".to_string()],
                    patterns: vec!["^[a-z]{4}$".to_string()],
                    url_prefixes: vec!["tenant.example".to_string()],
                    ..CredentialProviderConfig::default()
                },
            ),
        ]),
        ..NetworkProxyConfig::default()
    });
    let real_value = "backup_stage";
    let mut env = HashMap::from([("BACKUP_TOKEN".to_string(), real_value.to_string())]);

    broker.virtualize_child_env(&mut env);

    assert_eq!(env["BACKUP_TOKEN"], real_value);
}

#[test]
fn discovered_credential_aliases_rebind_when_the_destination_changes() {
    for (token, host_key) in [
        ("stripe_live_abcdefghijklmnopqrstuvwx", "STRIPE_HOST"),
        ("ghp_abcdefghijklmnopqrstuvwxyz1234567890", "GH_HOST"),
        (
            "sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
            "OPENAI_BASE_URL",
        ),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["STRIPE_API_KEY".to_string()],
            patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
            url_prefix_from_env: Some("STRIPE_HOST".to_string()),
            ..CredentialProviderConfig::default()
        });
        let authorization_header = format!("Bearer {token}");
        for host in ["first.example", "second.example"] {
            let host_value = if host_key == "OPENAI_BASE_URL" {
                format!("https://{host}/v1")
            } else {
                host.to_string()
            };
            let mut env = HashMap::from([
                (host_key.to_string(), host_value),
                ("AUTH_HEADER".to_string(), authorization_header.clone()),
            ]);

            broker.virtualize_child_env(&mut env);

            let mut headers = HeaderMap::new();
            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_str(&env["AUTH_HEADER"]).expect("valid dummy authentication"),
            );
            broker.inject_request_headers(&format!("https://{host}/v1"), &mut headers);
            assert_eq!(
                headers
                    .get(AUTHORIZATION)
                    .and_then(|value| value.to_str().ok()),
                Some(authorization_header.as_str()),
                "provider host: {host}"
            );
        }

        let mut unbound =
            HashMap::from([("AUTH_HEADER".to_string(), authorization_header.clone())]);
        broker.virtualize_child_env(&mut unbound);
        if host_key == "OPENAI_BASE_URL" {
            assert_ne!(unbound["AUTH_HEADER"], authorization_header);
        } else {
            assert_eq!(unbound["AUTH_HEADER"], authorization_header);
            assert!(!broker.host_requires_mitm("api.github.com", /*port*/ 443));
        }
    }
}

#[test]
fn credential_rotation_preserves_alias_destination_ownership() {
    for (key, rotated_key, host_key, prefix, static_host) in [
        (
            "PROVIDER_TOKEN",
            "PROVIDER_TOKEN",
            "PROVIDER_URL",
            "provider_",
            None,
        ),
        (
            "PROVIDER_TOKEN",
            "PROVIDER_TOKEN_FALLBACK",
            "PROVIDER_URL",
            "provider_",
            None,
        ),
        (
            "PROVIDER_TOKEN",
            "PROVIDER_TOKEN",
            "PROVIDER_URL",
            "provider_",
            Some("static.example"),
        ),
        (
            "GH_ENTERPRISE_TOKEN",
            "GH_ENTERPRISE_TOKEN",
            "GH_HOST",
            "ghp_",
            None,
        ),
        (
            "GH_ENTERPRISE_TOKEN",
            "GITHUB_ENTERPRISE_TOKEN",
            "GH_HOST",
            "ghp_",
            None,
        ),
        (
            "OPENAI_API_KEY",
            "OPENAI_API_KEY",
            "OPENAI_BASE_URL",
            "sk-proj-",
            Some("api.openai.com"),
        ),
    ] {
        for (environment, real_aliases, discover_parent) in [
            ("parent", false, false),
            ("child", false, false),
            ("parent", true, false),
            ("child", true, false),
            ("parent", true, true),
            ("child", true, true),
        ] {
            let broker = broker_for(CredentialProviderConfig {
                env: vec![
                    "PROVIDER_TOKEN".to_string(),
                    "PROVIDER_TOKEN_FALLBACK".to_string(),
                ],
                patterns: vec!["^provider_[a-z]{36}$".to_string()],
                url_prefixes: static_host
                    .map(|host| format!("https://{host}"))
                    .into_iter()
                    .collect(),
                url_prefix_from_env: Some("PROVIDER_URL".to_string()),
                ..CredentialProviderConfig::default()
            });
            let suffix_len = if key == "OPENAI_API_KEY" { 64 } else { 36 };
            let first = format!("{prefix}{}", "a".repeat(suffix_len));
            let second = format!("{prefix}{}", "b".repeat(suffix_len));
            let auxiliary = format!("{prefix}{}", "c".repeat(suffix_len));
            let endpoint = |host: &str| {
                if host_key == "GH_HOST" {
                    host.to_string()
                } else {
                    format!("https://{host}/v1")
                }
            };
            let mut env = HashMap::from([
                (key.to_string(), first.clone()),
                (host_key.to_string(), endpoint("first.example")),
                ("AUTH_HEADER".to_string(), format!("Bearer {first}")),
                (
                    "SECOND_AUTH_HEADER".to_string(),
                    format!("Bearer {auxiliary}"),
                ),
            ]);
            let parent_env = env.clone();
            broker.virtualize_child_env_for_environment(&mut env, Some("parent"));
            let old_dummy = env[key].clone();
            let alias_dummy = env["SECOND_AUTH_HEADER"]
                .strip_prefix("Bearer ")
                .unwrap()
                .to_string();
            assert_ne!(old_dummy, first);
            assert_ne!(alias_dummy, auxiliary);
            env.remove(key);
            env.insert(rotated_key.to_string(), second.clone());
            env.insert(host_key.to_string(), endpoint("second.example"));
            if real_aliases {
                env.insert("AUTH_HEADER".to_string(), format!("Bearer {first}"));
                env.insert(
                    "SECOND_AUTH_HEADER".to_string(),
                    format!("Bearer {auxiliary}"),
                );
            }
            if discover_parent {
                broker.discover_parent_credentials_for_environment(
                    &parent_env,
                    &env,
                    Some(environment),
                );
            }
            broker.virtualize_child_env_for_environment(&mut env, Some(environment));
            let new_dummy = env[rotated_key].clone();
            assert_eq!(
                env["AUTH_HEADER"],
                format!("Bearer {old_dummy}"),
                "{key}, {environment}, real_aliases={real_aliases}, discover_parent={discover_parent}"
            );
            assert_eq!(env["SECOND_AUTH_HEADER"], format!("Bearer {alias_dummy}"));
            assert!(!env.values().any(|value| {
                [&first, &second, &auxiliary]
                    .iter()
                    .any(|real| value.contains(real.as_str()))
            }));
            for (dummy, real, host, allowed) in [
                (&old_dummy, &first, "second.example", false),
                (&old_dummy, &first, "first.example", true),
                (&alias_dummy, &auxiliary, "second.example", false),
                (&alias_dummy, &auxiliary, "first.example", true),
                (&new_dummy, &second, "first.example", false),
                (&new_dummy, &second, "second.example", true),
            ] {
                let mut headers = HeaderMap::from_iter([(
                    AUTHORIZATION,
                    HeaderValue::from_str(&format!("Bearer {dummy}")).unwrap(),
                )]);
                broker.inject_request_headers_for_environment(
                    &format!("https://{host}/v1"),
                    &mut headers,
                    Some(environment),
                );
                assert_eq!(
                    headers[AUTHORIZATION],
                    format!("Bearer {}", if allowed { real } else { dummy }),
                    "{key}, {environment}, {host}, real_aliases={real_aliases}, discover_parent={discover_parent}"
                );
            }

            env.insert(host_key.to_string(), String::new());
            if real_aliases {
                env.insert("AUTH_HEADER".to_string(), format!("Bearer {first}"));
                env.insert(
                    "SECOND_AUTH_HEADER".to_string(),
                    format!("Bearer {auxiliary}"),
                );
            }
            if discover_parent {
                broker.discover_parent_credentials_for_environment(
                    &parent_env,
                    &env,
                    Some(environment),
                );
            }
            broker.virtualize_child_env_for_environment(&mut env, Some(environment));
            for host in ["first.example", "second.example"]
                .into_iter()
                .chain(static_host)
            {
                for (dummy, real) in [
                    (&old_dummy, &first),
                    (&alias_dummy, &auxiliary),
                    (&new_dummy, &second),
                ] {
                    let mut headers = HeaderMap::from_iter([(
                        AUTHORIZATION,
                        HeaderValue::from_str(&format!("Bearer {dummy}")).unwrap(),
                    )]);
                    broker.inject_request_headers_for_environment(
                        &format!("https://{host}/v1"),
                        &mut headers,
                        Some(environment),
                    );
                    assert_eq!(
                        headers[AUTHORIZATION],
                        format!(
                            "Bearer {}",
                            if Some(host) == static_host {
                                real
                            } else {
                                dummy
                            }
                        )
                    );
                }
            }
            let mut parent_headers = HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {old_dummy}")).unwrap(),
            )]);
            broker.inject_request_headers_for_environment(
                "https://first.example/v1",
                &mut parent_headers,
                Some("parent"),
            );
            assert_eq!(
                parent_headers[AUTHORIZATION],
                format!(
                    "Bearer {}",
                    if environment == "child" {
                        &first
                    } else {
                        &old_dummy
                    }
                )
            );
        }
    }
}

#[test]
fn configured_provider_accepts_anchored_alternatives_and_ascii_character_classes() {
    for (pattern, token) in [
        ("(?i)^token_[a-z]{24}$", "TOKEN_abcdefghijklmnopqrstuvwx"),
        ("(?i:^token_[a-z]{24}$)", "TOKEN_abcdefghijklmnopqrstuvwx"),
        (
            "(?x)   ^ token_[a-z]{24} $",
            "token_abcdefghijklmnopqrstuvwx",
        ),
        (
            "(?x)^token_[a-z]{24}$ # provider token",
            "token_abcdefghijklmnopqrstuvwx",
        ),
        (
            "(?x)^token_[a-z]{24} # [legacy provider\n$",
            "token_abcdefghijklmnopqrstuvwx",
        ),
        (r"\btoken_[a-z]{24}\b", "token_abcdefghijklmnopqrstuvwx"),
        (r"\Atoken_[a-z]{24}\z", "token_abcdefghijklmnopqrstuvwx"),
        (
            "^(token_[a-z]{8}|token_[a-z]{24})$",
            "token_abcdefghijklmnopqrstuvwx",
        ),
        (r"^token_\d{24}$", "token_012345678901234567890123"),
        ("^token_.{24}$", "token_abcdefghijklmnopqrstuvwx"),
        ("^token_[^:]{24}$", "token_abcdefghijklmnopqrstuvwx"),
        ("^token_[]$a-z]{8}$", "token_a$bcd]ef"),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("PROVIDER_TOKEN".to_string(), token.to_string())]);

        broker.virtualize_child_env(&mut env);

        let dummy = &env["PROVIDER_TOKEN"];
        assert_ne!(dummy, token, "credential pattern: {pattern}");
        assert!(dummy.is_ascii(), "credential pattern: {pattern}");
        assert!(
            regex::Regex::new(pattern)
                .expect("valid credential pattern")
                .is_match(dummy),
            "credential pattern: {pattern}"
        );

        let mut headers = HeaderMap::new();
        headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(&format!("Bearer {dummy}")).expect("valid dummy authentication"),
        );
        broker.inject_request_headers("https://api.provider.example/", &mut headers);
        assert_eq!(
            headers
                .get(AUTHORIZATION)
                .and_then(|value| value.to_str().ok()),
            Some(format!("Bearer {token}").as_str()),
            "credential pattern: {pattern}"
        );

        let replacement = if token.ends_with(|character: char| character.is_ascii_digit()) {
            '9'
        } else {
            'z'
        };
        let unknown = format!("{}{replacement}", &token[..token.len() - 1]);
        let mut copied = format!("AUTH_HEADER=Bearer {unknown}");
        assert!(
            !broker.virtualize_text(&mut copied, &env),
            "credential pattern: {pattern}"
        );
        assert!(!copied.contains(&unknown), "credential pattern: {pattern}");
    }
}

#[test]
fn configured_provider_preserves_word_boundaries_during_unbound_discovery() {
    let token = "token_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["PROVIDER_TOKEN".to_string()],
        patterns: vec![r"\btoken_[a-z]{24}\b".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let prefixed = format!("my{token}");
    let mut env = HashMap::from([
        ("APPLICATION_ID".to_string(), prefixed.clone()),
        ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
    ]);

    broker.virtualize_child_env(&mut env);

    assert_eq!(env["APPLICATION_ID"], prefixed);
    assert_ne!(env["AUTH_HEADER"], format!("Bearer {token}"));
}

#[test]
fn configured_provider_replaces_exact_known_values_with_lazy_patterns() {
    for (pattern, token) in [
        (r"^token_[a-z]+?$", "token_abcdefghijklmnopqrstuvwx"),
        (
            r"^token_(?:[a-z]|[a-z]{24})$",
            "token_abcdefghijklmnopqrstuvwx",
        ),
        (r"\btoken_[a-z]+?\b", "token_abcdefghijklmnopqrstuvwx"),
        (r"^token_\B[a-z]+?$", "token_abcdefghijklmnopqrstuvwx"),
        (r"^[a-z]{24}\b$", "abcabcabcabcabcabcabcabc"),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([
            ("PROVIDER_TOKEN".to_string(), token.to_string()),
            ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
            ("REPEATED".to_string(), format!("{token}\n{token}")),
            ("ADJACENT".to_string(), format!("é{token}é")),
            ("OVERLAPPED".to_string(), format!("Bearer abc{token}")),
        ]);

        broker.virtualize_child_env(&mut env);

        let dummy = &env["PROVIDER_TOKEN"];
        assert_ne!(dummy, token);
        assert_eq!(env["AUTH_HEADER"], format!("Bearer {dummy}"));
        assert_eq!(env["REPEATED"], format!("{dummy}\n{dummy}"));
        assert_eq!(
            env["ADJACENT"],
            format!(
                "é{}é",
                if pattern.contains(r"\b") {
                    token
                } else {
                    dummy
                }
            )
        );
        assert_eq!(
            env["OVERLAPPED"],
            format!(
                "Bearer abc{}",
                if pattern.starts_with(r"\b") {
                    token
                } else {
                    dummy
                }
            )
        );
        let mut snapshot = format!("{token}\nBearer {token}\n{token}");
        assert!(broker.virtualize_text(&mut snapshot, &env));
        assert_eq!(snapshot, format!("{dummy}\nBearer {dummy}\n{dummy}"));
    }
}

#[test]
fn configured_provider_discovers_complete_unregistered_values() {
    for (pattern, token) in [
        (r"^token_[a-z]+?$", "token_abcdefghijklmnopqrstuvwx"),
        (r"\btoken_[a-z]+?\b", "token_abcdefghijklmnopqrstuvwx"),
        (r"^token_\B[a-z]+?$", "token_abcdefghijklmnopqrstuvwx"),
        (
            r"^token_(?:[a-z]{8,32}|[a-z]{24}[0-9]{8})$",
            "token_abcdefghijklmnopqrstuvwx12345678",
        ),
        (
            r"^token_(?:[a-z]+|[a-z]+[0-9]+)$",
            "token_abcdefghijklmnopqrstuvwx12345678",
        ),
        (
            r"^token_(?:[a-z]{8,32}|[a-z]{24}_[0-9]{7})$",
            "token_abcdefghijklmnopqrstuvwx_1234567",
        ),
        (
            r"^token_(?:[a-z]{8,32}|[a-z]{24}-[0-9]{7})$",
            "token_abcdefghijklmnopqrstuvwx-1234567",
        ),
        (
            r"^token_(?:[a-z]+|[a-z]+/[a-z]+)$",
            "token_abcdefghijklmnopqrstuvwx/zyxwvutsrqponmlkjihgfedcb",
        ),
        (
            r"^token_(?:[a-z]{8,128}|[a-z]{24}\.[a-z]{24})$",
            "token_abcdefghijklmnopqrstuvwx.zyxwvutsrqponmlkjihgfedc",
        ),
        (
            r"\btoken_(?:[a-z]+|[a-z]+\+[a-z]+)\b",
            "token_abcdefghijklmnopqrstuvwx+zyxwvutsrqponmlkjihgfedcb",
        ),
        (
            r"^token_(?:[a-z]+|[a-z]+:[a-z]+)$",
            "token_abcdefghijklmnopqrstuvwx:zyxwvutsrqponmlkjihgfedcb",
        ),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([
            ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
            ("REPEATED".to_string(), format!("{token},{token}")),
        ]);

        let mut unknown_snapshot = format!("export AUTH_HEADER='Bearer {token}'");
        assert!(
            !broker.virtualize_text(&mut unknown_snapshot, &HashMap::new()),
            "{pattern}"
        );
        assert_eq!(
            unknown_snapshot, "export AUTH_HEADER='Bearer '",
            "{pattern}"
        );
        broker.virtualize_child_env(&mut env);

        let dummy = env["AUTH_HEADER"].strip_prefix("Bearer ").unwrap();
        assert_ne!(dummy, token, "{pattern}");
        assert_eq!(env["REPEATED"], format!("{dummy},{dummy}"), "{pattern}");
        let mut snapshot = format!("Bearer {token}");
        assert!(broker.virtualize_text(&mut snapshot, &env), "{pattern}");
        assert_eq!(snapshot, env["AUTH_HEADER"], "{pattern}");
        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&env["AUTH_HEADER"]).unwrap(),
        )]);
        broker.inject_request_headers("https://api.provider.example/", &mut headers);
        assert_eq!(
            headers,
            HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {token}")).unwrap(),
            )]),
            "{pattern}"
        );
    }
}

#[test]
fn mixed_provider_aliases_keep_credentials_on_separate_destinations() {
    let github = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";
    for (pattern, vendor, separator) in [
        ("^vendor_[a-z]{24}$", "vendor_abcdefghijklmnopqrstuvwx"),
        (
            r"^vendor_[a-z]{8}(?:\.[a-z]{8})?$",
            "vendor_abcdefgh.ijklmnop",
        ),
    ]
    .into_iter()
    .flat_map(|(pattern, vendor)| ["_", "-", ""].map(|separator| (pattern, vendor, separator)))
    {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["VENDOR_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.vendor.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let composite = format!("{github}{separator}{vendor}");
        let mut env = HashMap::from([("AUTH_BUNDLE".to_string(), composite.clone())]);
        broker.virtualize_child_env(&mut env);
        let records = broker.read_state();
        let github_dummy = records
            .credentials
            .iter()
            .find(|record| record.real_value == github)
            .expect("separate GitHub credential")
            .dummy_value
            .clone();
        let vendor_dummy = records
            .credentials
            .iter()
            .find(|record| record.real_value == vendor)
            .expect("separate vendor credential")
            .dummy_value
            .clone();
        drop(records);
        assert_eq!(
            env["AUTH_BUNDLE"],
            format!("{github_dummy}{separator}{vendor_dummy}")
        );
        let mut snapshot = composite;
        // Without canonical sources, the snapshot cannot authorize a multi-token alias.
        assert!(!broker.virtualize_text(&mut snapshot, &env));
        assert!(!snapshot.contains(github));
        assert!(!snapshot.contains(vendor));
        for (host, dummy, expected) in [
            ("api.github.com", &github_dummy, github),
            ("api.vendor.example", &vendor_dummy, vendor),
            ("api.github.com", &vendor_dummy, vendor_dummy.as_str()),
        ] {
            let mut headers = HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {dummy}")).unwrap(),
            )]);
            broker.inject_request_headers(&format!("https://{host}/"), &mut headers);
            assert_eq!(
                headers,
                HeaderMap::from_iter([(
                    AUTHORIZATION,
                    HeaderValue::from_str(&format!("Bearer {expected}")).unwrap(),
                )])
            );
        }
        let composite = format!("{github}{separator}{vendor}");
        let mut canonical = HashMap::from([("GH_TOKEN".to_string(), composite.clone())]);
        broker.virtualize_child_env(&mut canonical);
        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&format!("Bearer {}", canonical["GH_TOKEN"])).unwrap(),
        )]);
        broker.inject_request_headers("api.github.com", &mut headers);
        assert_eq!(
            headers,
            HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {composite}")).unwrap(),
            )])
        );
    }
}

#[test]
fn configured_provider_virtualizes_short_credentials_in_aliases_and_snapshots() {
    for (pattern, token, unregistered) in [
        ("^pin_[a-z]{8}$", "pin_abcdefgh", "pin_hgfedcba"),
        (r"\bpin_[a-z]{8}\b", "pin_abcdefgh", "pin_hgfedcba"),
        (
            "^(pin_[a-z]{4}|pin_[a-z]{8})$",
            "pin_abcdefgh",
            "pin_hgfedcba",
        ),
        ("(?i)^pin_[a-z]{8}$", "PIN_abcdefgh", "PIN_hgfedcba"),
        (
            "^(pin_[a-z]{8}|key_[a-z]{8})$",
            "key_abcdefgh",
            "key_hgfedcba",
        ),
        ("^pin/[a-z]{8}$", "pin/abcdefgh", "pin/hgfedcba"),
        (r"^pin\\[a-z]{8}$", r"pin\abcdefgh", r"pin\hgfedcba"),
    ] {
        let preserves_word_boundaries = pattern.contains(r"\b");
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_PASSWORD".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([
            ("PROVIDER_PASSWORD".to_string(), token.to_string()),
            ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
            ("BACKUP".to_string(), format!("backup_{token}_prod")),
            (
                "PATH".to_string(),
                format!("/opt/venvs/build_{token}_prod/bin:/usr/bin"),
            ),
            (
                "TOOL_PATH".to_string(),
                format!("tools/{token}/bin:/usr/bin"),
            ),
            (
                "WINDOWS_TOOL_PATH".to_string(),
                format!(r"tools\{token}\bin"),
            ),
            ("UNRELATED".to_string(), "pin_setting".to_string()),
        ]);

        broker.virtualize_child_env(&mut env);

        let dummy = env["PROVIDER_PASSWORD"].clone();
        assert_ne!(dummy, token, "credential pattern: {pattern}");
        assert_eq!(env["AUTH_HEADER"], format!("Bearer {dummy}"));
        let mut alias_only = env.clone();
        alias_only.remove("PROVIDER_PASSWORD");
        broker.virtualize_child_env(&mut alias_only);
        assert!(
            brokered_credential_marker_env_keys(&alias_only)
                .contains(&"PROVIDER_PASSWORD".to_string())
        );
        assert!(
            brokered_credential_marker_env_keys(&alias_only).contains(&"AUTH_HEADER".to_string())
        );
        assert!(
            brokered_credential_value_env_keys(&alias_only).contains(&"AUTH_HEADER".to_string())
        );
        assert_eq!(
            env["BACKUP"],
            if preserves_word_boundaries {
                format!("backup_{token}_prod")
            } else {
                format!("backup_{dummy}_prod")
            }
        );
        assert_eq!(
            env["PATH"],
            format!("/opt/venvs/build_{token}_prod/bin:/usr/bin")
        );
        assert_eq!(env["TOOL_PATH"], format!("tools/{token}/bin:/usr/bin"));
        assert_eq!(env["WINDOWS_TOOL_PATH"], format!(r"tools\{token}\bin"));
        assert_eq!(env["UNRELATED"], "pin_setting");
        let mut snapshot = format!("export AUTH_HEADER='Bearer {token}'");
        assert!(broker.virtualize_text(&mut snapshot, &env));
        assert_eq!(snapshot, format!("export AUTH_HEADER='Bearer {dummy}'"));
        for original_path in [
            "/opt/venvs/pin_hgfedcba/bin:/usr/bin",
            "tools/pin_hgfedcba/bin:/usr/bin",
            r"tools\pin_hgfedcba\bin",
        ] {
            let mut path = original_path.to_string();
            assert!(broker.virtualize_text(&mut path, &env));
            assert_eq!(path, original_path);
        }
        for (mut copied, expected_allowed) in [
            (
                format!("BACKUP=backup_{unregistered}_prod"),
                preserves_word_boundaries,
            ),
            (
                format!("WEBHOOK_URL=https://api.vendor.example/{unregistered}"),
                false,
            ),
        ] {
            assert_eq!(
                broker.virtualize_text(&mut copied, &env),
                expected_allowed,
                "credential pattern: {pattern}",
            );
            assert_eq!(
                copied.contains(unregistered),
                expected_allowed,
                "credential pattern: {pattern}",
            );
        }

        broker.restore_child_env(&mut env, &mut []);
        assert_eq!(env["PROVIDER_PASSWORD"], token);
        assert_eq!(env["AUTH_HEADER"], format!("Bearer {token}"));
        assert_eq!(env["BACKUP"], format!("backup_{token}_prod"));
        assert_eq!(
            env["PATH"],
            format!("/opt/venvs/build_{token}_prod/bin:/usr/bin")
        );
        assert_eq!(env["TOOL_PATH"], format!("tools/{token}/bin:/usr/bin"));
        assert_eq!(env["WINDOWS_TOOL_PATH"], format!(r"tools\{token}\bin"));
    }
}

#[test]
fn configured_provider_generates_bounded_independent_dummies() {
    let long_token = format!("token_{}", "a".repeat(4096));
    let long_broker = broker_for(CredentialProviderConfig {
        env: vec!["PROVIDER_TOKEN".to_string()],
        patterns: vec!["^token_[a-z]+$".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let mut long_env = HashMap::from([("PROVIDER_TOKEN".to_string(), long_token.clone())]);

    long_broker.virtualize_child_env(&mut long_env);

    let long_dummy = &long_env["PROVIDER_TOKEN"];
    assert_ne!(long_dummy, &long_token);
    assert!(long_dummy.len() <= 2048);

    let narrow_token = format!("token_{}", "a".repeat(64));
    for _ in 0..3 {
        let narrow_broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec!["^token_[ab]{64}$".to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            ..CredentialProviderConfig::default()
        });
        let mut narrow_env = HashMap::from([("PROVIDER_TOKEN".to_string(), narrow_token.clone())]);

        narrow_broker.virtualize_child_env(&mut narrow_env);

        let changed = narrow_token
            .bytes()
            .zip(narrow_env["PROVIDER_TOKEN"].bytes())
            .filter(|(real, dummy)| real != dummy)
            .count();
        assert!(changed >= 12, "dummy changed only {changed} bytes");
    }
}

#[test]
fn configured_provider_rejects_aliases_containing_disallowed_credentials() {
    let first = "token_abcdefghijklmnopqrstuvwx";
    let second = "token_zyxwvutsrqponmlkjihgfedc";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
        patterns: vec!["token_[a-z]{24}".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let source_env = HashMap::from([("FIRST_TOKEN".to_string(), first.to_string())]);

    assert!(
        broker
            .provider_sources_allowed(first, "", &source_env, |source| { source == "FIRST_TOKEN" })
    );
    assert!(!broker.provider_sources_allowed(
        &format!("{first}|{second}"),
        "",
        &source_env,
        |source| source == "FIRST_TOKEN",
    ));

    let overlapping = broker_for(CredentialProviderConfig {
        env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
        patterns: vec!["^(token_[a-z]{4}|token_[a-z]{8})$".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let first = "token_abcd";
    let second = "token_abcdefgh";
    for source_env in [
        HashMap::from([
            ("FIRST_TOKEN".to_string(), first.to_string()),
            ("SECOND_TOKEN".to_string(), second.to_string()),
        ]),
        HashMap::from([("FIRST_TOKEN".to_string(), first.to_string())]),
    ] {
        assert!(
            !overlapping.provider_sources_allowed(second, "", &source_env, |source| source
                == "FIRST_TOKEN",)
        );
    }
}

#[test]
fn configured_provider_preserves_operational_values_while_redacting_url_credentials() {
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["PROVIDER_PIN".to_string()],
        patterns: vec![r"^\d{3}$".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([
        ("PROVIDER_PIN".to_string(), "127".to_string()),
        ("AUTH_HEADER".to_string(), "Bearer 127".to_string()),
        (
            "HTTP_PROXY".to_string(),
            "http://127.0.0.1:3128".to_string(),
        ),
        ("PATH".to_string(), "/opt/sdk127/bin:/usr/bin".to_string()),
        ("HTTP_STATUS".to_string(), "443".to_string()),
        ("RETRIES".to_string(), "200".to_string()),
        (
            "WEBHOOK_URL".to_string(),
            "https://127.0.0.1/auth/127".to_string(),
        ),
    ]);

    broker.virtualize_child_env(&mut env);

    let dummy = env["PROVIDER_PIN"].clone();
    assert_ne!(dummy, "127");
    assert_eq!(env["AUTH_HEADER"], format!("Bearer {dummy}"));
    assert_eq!(env["HTTP_PROXY"], "http://127.0.0.1:3128");
    assert_eq!(env["PATH"], "/opt/sdk127/bin:/usr/bin");
    assert_eq!(env["HTTP_STATUS"], "443");
    assert_eq!(env["RETRIES"], "200");
    assert_eq!(
        env["WEBHOOK_URL"],
        format!("https://127.0.0.1/auth/{dummy}")
    );
    let mut ordinary_settings = "export HTTP_STATUS=443\nexport RETRIES=200\n".to_string();
    assert!(broker.virtualize_text(&mut ordinary_settings, &env));
    assert_eq!(
        ordinary_settings,
        "export HTTP_STATUS=443\nexport RETRIES=200\n"
    );
    let mut credential_alias = "AUTH_HEADER=Bearer 127".to_string();
    assert!(broker.virtualize_text(&mut credential_alias, &env));
    assert_eq!(credential_alias, format!("AUTH_HEADER=Bearer {dummy}"));

    broker.restore_child_env(&mut env, &mut []);
    assert_eq!(env["PROVIDER_PIN"], "127");
    assert_eq!(env["AUTH_HEADER"], "Bearer 127");
    assert_eq!(env["HTTP_PROXY"], "http://127.0.0.1:3128");
    assert_eq!(env["PATH"], "/opt/sdk127/bin:/usr/bin");
    assert_eq!(env["HTTP_STATUS"], "443");
    assert_eq!(env["RETRIES"], "200");
    assert_eq!(env["WEBHOOK_URL"], "https://127.0.0.1/auth/127");
}

#[test]
fn configured_provider_does_not_rescan_registered_credential_prefixes() {
    let token = "token_abcdefghijkl";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["PROVIDER_TOKEN".to_string()],
        patterns: vec!["token_[a-z]{4}".to_string(), "token_[a-z]{12}".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([("PROVIDER_TOKEN".to_string(), token.to_string())]);
    broker.virtualize_child_env(&mut env);
    let dummy = &env["PROVIDER_TOKEN"];

    let mut registered = format!("AUTH_HEADER=Bearer {dummy}");
    assert!(broker.virtualize_text(&mut registered, &env));
    assert_eq!(registered, format!("AUTH_HEADER=Bearer {dummy}"));

    let mut unknown = "AUTH_HEADER=Bearer token_zzzzzzzzzzzz".to_string();
    assert!(!broker.virtualize_text(&mut unknown, &env));
    assert_eq!(unknown, "AUTH_HEADER=Bearer ");
}

#[test]
fn configured_provider_does_not_register_a_credential_inside_an_existing_dummy() {
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["PRIMARY_TOKEN".to_string(), "SECONDARY_TOKEN".to_string()],
        patterns: vec!["token_[a-z]{4}".to_string(), "token_[a-z]{12}".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([(
        "PRIMARY_TOKEN".to_string(),
        "token_abcdefghijkl".to_string(),
    )]);
    broker.virtualize_child_env(&mut env);
    let primary_dummy = env["PRIMARY_TOKEN"].clone();
    let overlapping_real = primary_dummy[..10].to_string();
    env.insert("SECONDARY_TOKEN".to_string(), overlapping_real.clone());

    broker.virtualize_child_env(&mut env);

    assert_eq!(env["PRIMARY_TOKEN"], primary_dummy);
    assert_eq!(env["SECONDARY_TOKEN"], overlapping_real);
}

#[test]
fn builtin_dummy_rejects_known_and_late_credential_collisions() {
    for (custom_real, known_before_builtin) in [("mask", true), ("mask", false), ("pass", false)] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["CUSTOM_TOKEN".to_string()],
            patterns: if known_before_builtin {
                vec!["^[a-z]{4}$".to_string(), "^ghp_[A-Za-z0-9]+$".to_string()]
            } else {
                vec!["^(?:pass|mask)$".to_string()]
            },
            url_prefix_from_env: Some("CUSTOM_HOST".to_string()),
            ..CredentialProviderConfig::default()
        });
        if known_before_builtin {
            let mut unbound =
                HashMap::from([("CUSTOM_TOKEN".to_string(), custom_real.to_string())]);
            broker.virtualize_child_env(&mut unbound);
            assert!(broker.read_state().credentials.is_empty());
        }
        let github_real = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";
        let mut builtin_env = HashMap::from([("GH_TOKEN".to_string(), github_real.to_string())]);
        broker.virtualize_child_env(&mut builtin_env);
        let github_dummy = &builtin_env["GH_TOKEN"];
        if known_before_builtin {
            assert_eq!(github_dummy, github_real);
            assert!(broker.read_state().credentials.is_empty());
            continue;
        }
        assert!(github_dummy.starts_with("ghp_masked"));

        // The earlier dummy is not carried, so environment containment cannot reject the overlap.
        let mut late_env = HashMap::from([
            ("CUSTOM_TOKEN".to_string(), custom_real.to_string()),
            (
                "CUSTOM_HOST".to_string(),
                "api.provider.example".to_string(),
            ),
        ]);
        broker.virtualize_child_env(&mut late_env);
        assert_eq!(late_env["CUSTOM_TOKEN"], custom_real);
        assert_eq!(broker.read_state().credentials.len(), 1);

        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&format!("Bearer {github_dummy}")).unwrap(),
        )]);
        broker.inject_request_headers("api.github.com", &mut headers);
        assert_eq!(headers[AUTHORIZATION], format!("Bearer {github_real}"));
        let mut restored = github_dummy.clone();
        assert!(broker.restore_text(&mut restored));
        assert_eq!(restored, github_real);

        let mut headers =
            HeaderMap::from_iter([(AUTHORIZATION, HeaderValue::from_static("Bearer mask"))]);
        broker.inject_request_headers("https://api.provider.example/", &mut headers);
        assert_eq!(headers[AUTHORIZATION], "Bearer mask");
    }

    let broker = broker_for(CredentialProviderConfig {
        env: vec!["CUSTOM_TOKEN".to_string()],
        patterns: vec!["mask[a-z]{2}".to_string()],
        url_prefixes: vec!["https://custom.example".to_string()],
        ..CredentialProviderConfig::default()
    });
    let github_real = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";
    let mut env = HashMap::from([
        ("GH_TOKEN".to_string(), github_real.to_string()),
        ("CUSTOM_ALIAS".to_string(), "masked".to_string()),
    ]);
    broker.virtualize_child_env(&mut env);
    assert_eq!(env["GH_TOKEN"], github_real);
    assert!(!env.contains_key("CUSTOM_TOKEN"));
    assert!(
        broker
            .read_state()
            .credentials
            .iter()
            .all(|credential| { credential.env_var == "CUSTOM_TOKEN" })
    );
    let alias_dummy = &env["CUSTOM_ALIAS"];
    assert_ne!(alias_dummy, "masked");
    let mut headers = HeaderMap::from_iter([(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {alias_dummy}")).unwrap(),
    )]);
    let original = headers.clone();
    broker.inject_request_headers("https://unrelated.example/", &mut headers);
    assert_eq!(headers, original);
    broker.inject_request_headers("https://custom.example/", &mut headers);
    assert_eq!(headers[AUTHORIZATION], "Bearer masked");
    let mut restored = alias_dummy.clone();
    assert!(broker.restore_text(&mut restored));
    assert_eq!(restored, "masked");
}

#[test]
fn configured_provider_reload_preserves_credentials_and_rejects_overlapping_sources() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    let provider = CredentialProviderConfig {
        env: vec!["PROVIDER_TOKEN".to_string()],
        patterns: vec!["provider_[a-z]{24}".to_string()],
        url_prefixes: vec!["api.provider.example".to_string()],
        ..CredentialProviderConfig::default()
    };
    let broker = broker_for(provider.clone());
    let mut env = HashMap::from([("PROVIDER_TOKEN".to_string(), token.to_string())]);
    broker.virtualize_child_env(&mut env);
    let dummy = env["PROVIDER_TOKEN"].clone();

    let overlapping_builtin = CredentialProviderConfig {
        env: vec!["GH_TOKEN".to_string()],
        url_prefixes: vec!["builtin-overlap.example".to_string()],
        ..provider.clone()
    };
    let overlapping_configured = CredentialProviderConfig {
        url_prefixes: vec!["configured-overlap.example".to_string()],
        ..provider.clone()
    };
    let unrelated = CredentialProviderConfig {
        env: vec!["ANOTHER_TOKEN".to_string()],
        url_prefixes: vec!["another.example".to_string()],
        ..provider.clone()
    };
    broker.configure(&NetworkProxyConfig {
        credential_broker: true,
        credential_providers: BTreeMap::from([
            ("aaa-overlap".to_string(), overlapping_configured),
            ("builtin".to_string(), overlapping_builtin),
            ("custom".to_string(), provider),
            ("second".to_string(), unrelated),
        ]),
        ..NetworkProxyConfig::default()
    });

    broker.virtualize_child_env(&mut env);
    assert_eq!(env["PROVIDER_TOKEN"], dummy);
    assert!(!broker.host_requires_mitm("builtin-overlap.example", /*port*/ 443));
    assert!(!broker.host_requires_mitm("configured-overlap.example", /*port*/ 443));
    let mut headers = HeaderMap::new();
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {dummy}")).expect("valid authentication"),
    );
    broker.inject_request_headers("https://api.provider.example/", &mut headers);
    assert_eq!(
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok()),
        Some(format!("Bearer {token}").as_str())
    );
}

#[test]
fn configured_provider_preserves_bearer_token_basic_and_custom_header_auth() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    let github_token = "ghp_abcdefghijklmnopqrstuvwxyz1234567890";
    for (method, header_name, header_value) in [
        (
            CredentialAuthMethod::Bearer,
            "authorization",
            format!("Bearer {token}"),
        ),
        (
            CredentialAuthMethod::Token,
            "authorization",
            format!("token {token}"),
        ),
        (
            CredentialAuthMethod::Basic,
            "authorization",
            format!(
                "Basic {}",
                base64::engine::general_purpose::STANDARD.encode(format!("user:{token}"))
            ),
        ),
        (
            CredentialAuthMethod::Header,
            "x-api-key",
            format!("Key {token}"),
        ),
    ] {
        let host = if method == CredentialAuthMethod::Header {
            "api.github.com"
        } else {
            "api.provider.example"
        };
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec!["provider_[a-z]{24}".to_string()],
            url_prefixes: vec![host.to_string()],
            auth: if method == CredentialAuthMethod::Header {
                vec![CredentialAuthMethod::Bearer, method]
            } else {
                vec![method]
            },
            header: (method == CredentialAuthMethod::Header).then(|| "x-api-key".to_string()),
            prefix: (method == CredentialAuthMethod::Header).then(|| "Key ".to_string()),
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("PROVIDER_TOKEN".to_string(), token.to_string())]);
        if method == CredentialAuthMethod::Header {
            env.insert("GH_TOKEN".to_string(), github_token.to_string());
        }
        broker.virtualize_child_env(&mut env);
        let dummy = &env["PROVIDER_TOKEN"];
        let dummy_header = if method == CredentialAuthMethod::Basic {
            format!(
                "Basic {}",
                base64::engine::general_purpose::STANDARD.encode(format!("user:{dummy}"))
            )
        } else {
            header_value.replace(token, dummy)
        };
        let mut headers = HeaderMap::new();
        headers.insert(
            rama_http::HeaderName::from_bytes(header_name.as_bytes()).expect("valid header"),
            HeaderValue::from_str(&dummy_header).expect("valid dummy authentication"),
        );
        if method == CredentialAuthMethod::Header {
            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_static("Bearer unrelated-session-token"),
            );
        }

        broker.inject_request_headers(&format!("https://{host}/"), &mut headers);

        assert_eq!(
            headers
                .get(header_name)
                .and_then(|value| value.to_str().ok()),
            Some(header_value.as_str()),
            "authentication method: {method:?}"
        );
        if method == CredentialAuthMethod::Header {
            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {dummy}"))
                    .expect("valid dummy authentication"),
            );
            headers.insert(
                "x-api-key",
                HeaderValue::from_str(&dummy_header).expect("valid dummy authentication"),
            );
            broker.inject_request_headers(&format!("https://{host}/"), &mut headers);
            assert_eq!(
                headers
                    .get(AUTHORIZATION)
                    .and_then(|value| value.to_str().ok()),
                Some(format!("Bearer {token}").as_str())
            );
            assert_eq!(
                headers
                    .get("x-api-key")
                    .and_then(|value| value.to_str().ok()),
                Some(header_value.as_str())
            );

            headers.insert(
                AUTHORIZATION,
                HeaderValue::from_str(&format!("Bearer {}", env["GH_TOKEN"]))
                    .expect("valid dummy authentication"),
            );
            headers.insert(
                "x-api-key",
                HeaderValue::from_str(&dummy_header).expect("valid dummy authentication"),
            );
            broker.inject_request_headers(&format!("https://{host}/"), &mut headers);
            assert_eq!(
                headers
                    .get(AUTHORIZATION)
                    .and_then(|value| value.to_str().ok()),
                Some(format!("Bearer {github_token}").as_str())
            );
            assert_eq!(
                headers
                    .get("x-api-key")
                    .and_then(|value| value.to_str().ok()),
                Some(header_value.as_str())
            );
        }
    }
}

#[test]
fn configured_provider_translates_full_basic_pairs_only_on_exact_match() {
    let token = "user:provider_abcdefghijklmnopqrstuvwx:abcd";
    for (pattern, brokered) in [
        ("^user:provider_[a-z]{24}:[a-z]{4}$", true),
        ("^[a-z]{4}(?::provider_[a-z]{24}:[a-z]{4})?$", true),
        (
            "^(?:user:provider_abcdefghijklmnopqrstuvwx:abcd|[a-z]{32})$",
            false,
        ),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_CREDENTIALS".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            auth: vec![CredentialAuthMethod::Basic],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("PROVIDER_CREDENTIALS".to_string(), token.to_string())]);
        broker.virtualize_child_env(&mut env);
        let dummy = &env["PROVIDER_CREDENTIALS"];
        assert_eq!(dummy != token, brokered);

        for (destination, suffix, injected) in [
            ("https://api.provider.example/", "", true),
            ("https://api.provider.example/", "extra", false),
            ("https://other.example/", "", false),
        ] {
            // curl --user adds an empty password when the argument has no colon.
            let pair = if dummy.contains(':') {
                dummy.clone()
            } else {
                format!("{dummy}:")
            };
            let input = format!("{pair}{suffix}");
            let header = |value: &str| {
                HeaderMap::from_iter([(
                    AUTHORIZATION,
                    HeaderValue::from_str(&format!(
                        "bAsIc {}",
                        base64::engine::general_purpose::STANDARD.encode(value)
                    ))
                    .expect("valid Basic authentication"),
                )])
            };
            let mut headers = header(&input);

            broker.inject_request_headers(destination, &mut headers);

            assert_eq!(headers, header(if injected { token } else { &input }));
        }
    }
}

#[test]
fn configured_provider_generates_unicode_basic_dummies() {
    for (pattern, secret, token) in [
        (
            "^pass_wörd[a-z]{8} $",
            "pass_wördabcdefgh ".to_string(),
            "pass_wördabcdefgh ".to_string(),
        ),
        (
            r"^pass_\B[éöü]{24}[a-z]$",
            "éöü".repeat(8),
            format!("pass_{}a", "éöü".repeat(8)),
        ),
        (r"^(?:α{32}|β{32})$", "α".repeat(32), "α".repeat(32)),
        (
            r"^(?:α{32}|β{32}|\x00{32})$",
            "α".repeat(32),
            "α".repeat(32),
        ),
        (
            r"^pass_\B(?:[éöü]{24}|[-+]{24})[a-z]$",
            "éöü".repeat(8),
            format!("pass_{}a", "éöü".repeat(8)),
        ),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_PASSWORD".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: vec!["api.provider.example".to_string()],
            auth: vec![CredentialAuthMethod::Basic],
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("PROVIDER_PASSWORD".to_string(), token.clone())]);

        broker.virtualize_child_env(&mut env);

        let dummy = &env["PROVIDER_PASSWORD"];
        assert_ne!(dummy, &token);
        assert!(!dummy.contains('\0'));
        assert!(!dummy.contains(&secret));
        assert!(regex::Regex::new(pattern).unwrap().is_match(dummy));
        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&format!(
                "Basic {}",
                base64::engine::general_purpose::STANDARD.encode(format!("user:{dummy}"))
            ))
            .expect("valid dummy authentication"),
        )]);
        broker.inject_request_headers("https://api.provider.example/", &mut headers);
        let expected = format!(
            "Basic {}",
            base64::engine::general_purpose::STANDARD.encode(format!("user:{token}"))
        );
        assert_eq!(
            headers
                .get(AUTHORIZATION)
                .and_then(|value| value.to_str().ok()),
            Some(expected.as_str())
        );
    }
}

#[test]
fn configured_provider_does_not_break_usable_auth_methods_when_generating_dummies() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    for (alternative, method) in [
        "β{32}",
        "provider_[a-z]{23} ",
        " provider_[a-z]{23}",
        "provider_[a-z]{23}\\t",
        "provider_[a-z]{12}:[a-z]{12}",
    ]
    .into_iter()
    .flat_map(|alternative| {
        [CredentialAuthMethod::Bearer, CredentialAuthMethod::Header]
            .map(|method| (alternative, method))
    })
    .chain(std::iter::once((r"\x00{24}", CredentialAuthMethod::Basic)))
    {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_PASSWORD".to_string()],
            patterns: vec![format!("^(?:{token}|{alternative})$")],
            url_prefixes: vec!["api.provider.example".to_string()],
            auth: vec![method, CredentialAuthMethod::Basic],
            header: (method == CredentialAuthMethod::Header).then(|| "x-api-key".to_string()),
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("PROVIDER_PASSWORD".to_string(), token.to_string())]);

        broker.virtualize_child_env(&mut env);

        assert_eq!(env["PROVIDER_PASSWORD"], token);
    }
}

#[test]
fn configured_basic_dummies_preserve_username_password_and_whole_value_auth() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    let second = "provider_zyxwvutsrqponmlkjihgfedcb";
    let github = "ghp_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGH";
    let broker = broker_for(CredentialProviderConfig {
        env: vec![
            "PROVIDER_TOKEN".to_string(),
            "PROVIDER_SECRET".to_string(),
            "PROVIDER_COPY".to_string(),
        ],
        patterns: vec!["^provider_(?:[a-z]{24}|[a-z]{12}:[a-z]{12})$".to_string()],
        url_prefixes: vec!["https://api.github.com/v1".to_string()],
        auth: vec![CredentialAuthMethod::Basic],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([
        ("PROVIDER_TOKEN".to_string(), token.to_string()),
        ("PROVIDER_SECRET".to_string(), second.to_string()),
        ("PROVIDER_COPY".to_string(), token.to_string()),
        ("GH_TOKEN".to_string(), github.to_string()),
    ]);
    broker.virtualize_child_env(&mut env);
    let dummy = &env["PROVIDER_TOKEN"];
    assert_ne!(dummy, token);
    assert!(!dummy.contains(':'));
    for (input, expected) in [
        (
            format!("{dummy}:x-oauth-basic"),
            format!("{token}:x-oauth-basic"),
        ),
        (format!("user:{dummy}"), format!("user:{token}")),
        (format!("{dummy}:{dummy}"), format!("{token}:{token}")),
        (
            format!("{dummy}:{}", env["PROVIDER_COPY"]),
            format!("{token}:{token}"),
        ),
        (
            format!("{}:{dummy}", env["PROVIDER_COPY"]),
            format!("{token}:{token}"),
        ),
        (
            format!("{dummy}:{}", env["PROVIDER_SECRET"]),
            format!("{token}:{second}"),
        ),
        (
            format!("{}:{dummy}", env["PROVIDER_SECRET"]),
            format!("{second}:{token}"),
        ),
        (
            format!("{}:{dummy}", env["GH_TOKEN"]),
            format!("{github}:{token}"),
        ),
        (
            format!("{dummy}:{}", env["GH_TOKEN"]),
            format!("{token}:{github}"),
        ),
        (dummy.clone(), token.to_string()),
    ] {
        let headers_for = |value: &str| {
            HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&format!(
                    "Basic {}",
                    base64::engine::general_purpose::STANDARD.encode(value)
                ))
                .unwrap(),
            )])
        };
        let mut headers = headers_for(&input);
        broker.inject_request_headers("https://other.example/", &mut headers);
        assert_eq!(headers, headers_for(&input));
        broker.inject_request_headers(
            "https://api.github.com/public/%2e%2e/v1/models",
            &mut headers,
        );
        assert_eq!(headers, headers_for(&input));
        broker.inject_request_headers("https://api.github.com/v1/models", &mut headers);
        assert_eq!(headers, headers_for(&expected));
    }
}

#[test]
fn configured_provider_destination_history_is_scoped_to_the_environment() {
    let token = "stripe_live_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["STRIPE_API_KEY".to_string()],
        patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
        url_prefixes: vec!["static.example".to_string()],
        url_prefix_from_env: Some("STRIPE_HOST".to_string()),
        ..CredentialProviderConfig::default()
    });
    let mut first_env = HashMap::from([
        ("STRIPE_API_KEY".to_string(), token.to_string()),
        ("STRIPE_HOST".to_string(), "first.example".to_string()),
    ]);
    broker.virtualize_child_env_for_environment(&mut first_env, Some("first-environment"));
    let first_dummy = first_env["STRIPE_API_KEY"].clone();
    let mut second_env = HashMap::from([
        ("STRIPE_HOST".to_string(), "second.example".to_string()),
        ("AUTH_HEADER".to_string(), format!("Bearer {first_dummy}")),
    ]);

    broker.virtualize_child_env_for_environment(&mut second_env, Some("second-environment"));

    let second_dummy = second_env["AUTH_HEADER"]
        .strip_prefix("Bearer ")
        .expect("dummy bearer credential")
        .to_string();
    assert_eq!(second_dummy, first_dummy);
    assert!(!second_env.contains_key("STRIPE_API_KEY"));
    assert_eq!(second_env["AUTH_HEADER"], format!("Bearer {second_dummy}"));
    let translated = |environment_id: &str, destination: &str, dummy: &str| {
        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&format!("Bearer {dummy}")).expect("valid dummy authentication"),
        )]);
        broker.inject_request_headers_for_environment(
            &format!("https://{destination}/"),
            &mut headers,
            Some(environment_id),
        );
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok())
            .expect("authorization header")
            .to_string()
    };
    assert_eq!(
        translated("first-environment", "first.example", &first_dummy),
        format!("Bearer {token}")
    );
    assert_eq!(
        translated("second-environment", "second.example", &second_dummy),
        format!("Bearer {token}")
    );
    assert_eq!(
        translated("first-environment", "static.example", &first_dummy),
        format!("Bearer {token}")
    );

    second_env.insert("STRIPE_HOST".to_string(), "third.example".to_string());
    broker.virtualize_child_env_for_environment(&mut second_env, Some("second-environment"));

    assert_eq!(second_env["AUTH_HEADER"], format!("Bearer {second_dummy}"));
    assert_eq!(
        translated("second-environment", "second.example", &second_dummy),
        format!("Bearer {token}")
    );
    assert_eq!(
        translated("second-environment", "third.example", &second_dummy),
        format!("Bearer {token}")
    );
    assert_eq!(
        translated("first-environment", "first.example", &first_dummy),
        format!("Bearer {token}")
    );
    assert_eq!(
        translated("second-environment", "first.example", &second_dummy),
        format!("Bearer {second_dummy}")
    );
    for host in ["second.example", "third.example"] {
        assert_eq!(
            translated("first-environment", host, &first_dummy),
            format!("Bearer {first_dummy}")
        );
    }

    let revision = broker.config_revision();
    broker.configure(&NetworkProxyConfig {
        credential_broker: true,
        ..NetworkProxyConfig::default()
    });
    assert_eq!(broker.config_revision(), revision + 1);
    for host in ["second.example", "third.example", "static.example"] {
        assert_eq!(
            translated("second-environment", host, &second_dummy),
            format!("Bearer {second_dummy}")
        );
        assert!(
            !broker
                .host_protocols_for_environment(host, /*port*/ 443, Some("second-environment"),)
                .tls
        );
    }
}

#[test]
fn configured_provider_preserves_filtered_destinations_but_honors_explicit_overrides() {
    let token = "stripe_live_abcdefghijklmnopqrstuvwx";
    let second_token = "stripe_live_zyxwvutsrqponmlkjihgfedc";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["STRIPE_API_KEY".to_string()],
        patterns: vec!["^stripe_live_[a-z]{24}$".to_string()],
        url_prefix_from_env: Some("STRIPE_HOST".to_string()),
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([
        ("STRIPE_API_KEY".to_string(), token.to_string()),
        ("STRIPE_HOST".to_string(), "first.example".to_string()),
        ("AUTH_HEADER".to_string(), format!("Bearer {token}")),
        (
            "SECOND_AUTH_HEADER".to_string(),
            format!("Bearer {second_token}"),
        ),
    ]);
    broker.virtualize_child_env_for_environment(&mut env, Some("environment"));
    let dummy = env["STRIPE_API_KEY"].clone();

    let mut filtered_child = env.clone();
    filtered_child.remove("STRIPE_HOST");
    let expected = filtered_child.clone();
    broker.virtualize_child_env_for_environment(&mut filtered_child, Some("filtered-child"));
    assert_eq!(filtered_child, expected);
    for (alias, real) in [("AUTH_HEADER", token), ("SECOND_AUTH_HEADER", second_token)] {
        let mut headers = HeaderMap::from_iter([(
            AUTHORIZATION,
            HeaderValue::from_str(&filtered_child[alias]).unwrap(),
        )]);
        broker.inject_request_headers_for_environment(
            "https://first.example/",
            &mut headers,
            Some("filtered-child"),
        );
        assert_eq!(headers[AUTHORIZATION], format!("Bearer {real}"));
    }

    let mut child_env = env.clone();
    child_env.insert("STRIPE_HOST".to_string(), "child.example".to_string());
    broker.virtualize_child_env_for_environment(&mut child_env, Some("child"));
    child_env.remove("STRIPE_HOST");
    env.remove("STRIPE_HOST");
    for (environment, destination, current_env) in [
        ("environment", "first.example", &mut env),
        ("child", "child.example", &mut child_env),
    ] {
        let expected = current_env.clone();
        broker.virtualize_child_env_for_environment(current_env, Some(environment));
        assert_eq!(*current_env, expected);
        for (alias, real) in [("AUTH_HEADER", token), ("SECOND_AUTH_HEADER", second_token)] {
            let mut headers = HeaderMap::from_iter([(
                AUTHORIZATION,
                HeaderValue::from_str(&current_env[alias]).unwrap(),
            )]);
            broker.inject_request_headers_for_environment(
                &format!("https://{destination}/"),
                &mut headers,
                Some(environment),
            );
            assert_eq!(headers[AUTHORIZATION], format!("Bearer {real}"));
        }
    }

    env.insert("STRIPE_HOST".to_string(), String::new());
    broker.virtualize_child_env_for_environment(&mut env, Some("environment"));

    assert_eq!(env["STRIPE_API_KEY"], token);
    assert_eq!(env["AUTH_HEADER"], format!("Bearer {token}"));
    assert_eq!(env["SECOND_AUTH_HEADER"], format!("Bearer {second_token}"));
    let mut headers = HeaderMap::from_iter([(
        AUTHORIZATION,
        HeaderValue::from_str(&format!("Bearer {dummy}")).expect("valid dummy authentication"),
    )]);
    broker.inject_request_headers_for_environment(
        "https://first.example/",
        &mut headers,
        Some("environment"),
    );
    assert_eq!(
        headers
            .get(AUTHORIZATION)
            .and_then(|value| value.to_str().ok()),
        Some(format!("Bearer {dummy}").as_str())
    );
    assert!(
        !broker
            .host_protocols_for_environment("first.example", /*port*/ 443, Some("environment"))
            .tls
    );
}

#[test]
fn explicit_invalid_destinations_clear_previous_dynamic_bindings() {
    for (key, host_key, token, static_host) in [
        (
            "GH_ENTERPRISE_TOKEN",
            "GH_HOST",
            "ghp_abcdefghijklmnopqrstuvwxyz0123456789",
            None,
        ),
        (
            "GITHUB_ENTERPRISE_TOKEN",
            "GH_HOST",
            "ghp_abcdefghijklmnopqrstuvwxyz0123456789",
            None,
        ),
        (
            "OPENAI_API_KEY",
            "OPENAI_BASE_URL",
            "sk-proj-abcdefghijklmnopqrstuvwxyz0123456789",
            Some("api.openai.com"),
        ),
        (
            "PROVIDER_TOKEN",
            "PROVIDER_ENDPOINT",
            "provider_abcdefghijklmnopqrstuvwx",
            Some("static.example"),
        ),
        (
            "PROVIDER_TOKEN",
            "PROVIDER_ENDPOINT",
            "provider_abcdefghijklmnopqrstuvwx",
            None,
        ),
    ] {
        for use_real in [false, true] {
            for use_alias in [false, true] {
                for invalid in [
                    "",
                    " ",
                    "not a valid destination",
                    "http://untrusted.example",
                ]
                .into_iter()
                .chain((key == "PROVIDER_TOKEN").then_some("https://*.example"))
                .chain((host_key == "GH_HOST").then_some("github.com"))
                .chain(
                    (host_key == "GH_HOST")
                        .then_some([
                            "second.example:bad-port",
                            "127.0.0.1:bad-port",
                            "[::1]bad",
                            "[::1]:bad-port",
                            "second.example:99999",
                            "[example.com]",
                        ])
                        .into_iter()
                        .flatten(),
                ) {
                    let broker = broker_for(CredentialProviderConfig {
                        env: vec!["PROVIDER_TOKEN".to_string()],
                        patterns: vec!["^provider_[a-z]{24}$".to_string()],
                        url_prefixes: static_host
                            .map(|host| format!("https://{host}"))
                            .into_iter()
                            .collect(),
                        url_prefix_from_env: Some("PROVIDER_ENDPOINT".to_string()),
                        ..CredentialProviderConfig::default()
                    });
                    let mut env = HashMap::from([
                        (key.to_string(), token.to_string()),
                        (
                            host_key.to_string(),
                            if host_key == "GH_HOST" {
                                "first.example".to_string()
                            } else {
                                "https://first.example/v1".to_string()
                            },
                        ),
                    ]);
                    broker.virtualize_child_env(&mut env);
                    let dummy = env[key].clone();
                    let second_host = static_host.unwrap_or("second.example");
                    env.insert(
                        host_key.to_string(),
                        if host_key == "GH_HOST" {
                            second_host.to_string()
                        } else {
                            format!("https://{second_host}/v1")
                        },
                    );
                    broker.virtualize_child_env(&mut env);
                    assert!(broker.host_requires_mitm("first.example", /*port*/ 443));
                    env.clear();
                    let value = if use_real { token } else { &dummy };
                    let (input_key, input_value) = if use_alias {
                        ("AUTH_HEADER", format!("Bearer {value}"))
                    } else {
                        (key, value.to_string())
                    };
                    env.insert(input_key.to_string(), input_value);
                    env.insert(host_key.to_string(), invalid.to_string());
                    broker.virtualize_child_env(&mut env);

                    for host in ["first.example", second_host] {
                        let expected = if static_host == Some(host) {
                            token
                        } else {
                            &dummy
                        };
                        let mut headers = HeaderMap::from_iter([(
                            AUTHORIZATION,
                            HeaderValue::from_str(&format!("Bearer {dummy}")).unwrap(),
                        )]);
                        broker.inject_request_headers(&format!("https://{host}/v1"), &mut headers);
                        assert_eq!(
                            headers[AUTHORIZATION],
                            format!("Bearer {expected}"),
                            "{key}, {invalid:?}, {host}, real={use_real}, alias={use_alias}"
                        );
                    }
                    assert!(!broker.host_requires_mitm("first.example", /*port*/ 443));
                    if host_key == "GH_HOST" {
                        for _ in 0..2 {
                            broker.virtualize_child_env(&mut env);
                            assert_eq!(
                                env[input_key],
                                if use_alias {
                                    format!("Bearer {token}")
                                } else {
                                    token.to_string()
                                },
                                "{key}, {invalid:?}, real={use_real}, alias={use_alias}"
                            );
                            for cloud in ["api.github.com", "github.com", "tenant.ghe.com"] {
                                assert!(!broker.host_requires_mitm(cloud, /*port*/ 443));
                            }
                        }

                        env.insert(host_key.to_string(), "restored.example".to_string());
                        broker.virtualize_child_env(&mut env);
                        let restored_dummy = if use_alias {
                            env[input_key].strip_prefix("Bearer ").unwrap()
                        } else {
                            &env[input_key]
                        };
                        assert_ne!(restored_dummy, token);
                        let mut headers = HeaderMap::from_iter([(
                            AUTHORIZATION,
                            HeaderValue::from_str(&format!("Bearer {restored_dummy}")).unwrap(),
                        )]);
                        broker.inject_request_headers("https://restored.example/", &mut headers);
                        assert_eq!(headers[AUTHORIZATION], format!("Bearer {token}"));
                        assert!(!broker.host_requires_mitm("first.example", /*port*/ 443));
                        assert!(!broker.host_requires_mitm("second.example", /*port*/ 443));
                        assert!(!broker.host_requires_mitm("api.github.com", /*port*/ 443));
                        env.clear();
                        env.insert("GH_TOKEN".to_string(), token.to_string());
                        broker.virtualize_child_env(&mut env);
                        let mut headers = HeaderMap::from_iter([(
                            AUTHORIZATION,
                            HeaderValue::from_str(&format!("Bearer {}", env["GH_TOKEN"])).unwrap(),
                        )]);
                        broker.inject_request_headers("https://api.github.com/", &mut headers);
                        assert_eq!(headers[AUTHORIZATION], format!("Bearer {token}"));
                    }
                }
            }
        }
    }
}

#[test]
fn configured_provider_limits_injection_to_url_prefixes() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    let broker = broker_for(CredentialProviderConfig {
        env: vec!["PROVIDER_TOKEN".to_string()],
        patterns: vec!["provider_[a-z]{24}".to_string()],
        url_prefixes: vec![
            "https://root.provider.example".to_string(),
            "https://api.provider.example/v1".to_string(),
            "enterprise.example/v2/".to_string(),
            "https://*.provider.example:8443/private".to_string(),
            "http://localhost:443/v1".to_string(),
            "127.0.0.1:443/v1".to_string(),
            "http://[::1]:443/v1".to_string(),
            "http://localhost:8080/v1".to_string(),
            "localhost/v2".to_string(),
            "https://localhost:443/v3".to_string(),
            "https://localhost:80/v4".to_string(),
        ],
        ..CredentialProviderConfig::default()
    });
    let mut env = HashMap::from([("PROVIDER_TOKEN".to_string(), token.to_string())]);
    broker.virtualize_child_env(&mut env);
    let dummy = &env["PROVIDER_TOKEN"];
    assert!(broker.host_requires_mitm("team.provider.example", /*port*/ 8443));
    assert!(!broker.host_requires_mitm("team.provider.example", /*port*/ 443));

    for (destination, injected) in [
        ("root.provider.example", false),
        ("https://root.provider.example/models", true),
        ("https://api.provider.example/v1", true),
        ("https://api.provider.example/v1/models?limit=1", true),
        ("https://api.provider.example/v10/models", false),
        ("https://api.provider.example/private", false),
        (
            "https://api.provider.example/public/%2e%2e/v1/models",
            false,
        ),
        ("https://api.provider.example/v1%2f../private", false),
        ("http://api.provider.example/v1", false),
        ("https://enterprise.example/v2/models", true),
        ("https://enterprise.example/v2", false),
        ("https://team.provider.example:8443/private/models", true),
        ("https://team.provider.example/private/models", false),
        ("https://provider.example:8443/private/models", false),
        ("http://localhost:443/v1/models", true),
        ("http://localhost/v1/models", false),
        ("https://localhost/v1/models", false),
        ("http://127.0.0.1:443/v1/models", true),
        ("http://127.0.0.1/v1/models", false),
        ("http://[::1]:443/v1/models", true),
        ("http://[::1]/v1/models", false),
        ("http://localhost:8080/v1/models", true),
        ("http://localhost/v2/models", true),
        ("http://localhost:443/v2/models", false),
        ("https://localhost/v3/models", true),
        ("http://localhost:443/v3/models", false),
        ("https://localhost:80/v4/models", true),
        ("https://localhost/v4/models", false),
    ] {
        let dummy_header = format!("Bearer {dummy}");
        let mut headers = HeaderMap::new();
        headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(&dummy_header).expect("valid dummy authentication"),
        );

        broker.inject_request_headers(destination, &mut headers);

        let expected = if injected {
            format!("Bearer {token}")
        } else {
            dummy_header
        };
        assert_eq!(
            headers
                .get(AUTHORIZATION)
                .and_then(|value| value.to_str().ok()),
            Some(expected.as_str()),
            "destination: {destination}"
        );
    }
}

#[test]
fn configured_provider_accepts_hostname_or_https_url_from_one_environment_key() {
    let token = "provider_abcdefghijklmnopqrstuvwx";
    for (host_value, expected_host) in [
        ("enterprise.example", Some("enterprise.example")),
        ("https://gateway.example/v1", Some("gateway.example")),
        ("http://plaintext.example/v1", None),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["PROVIDER_TOKEN".to_string()],
            patterns: vec!["provider_[a-z]{24}".to_string()],
            url_prefix_from_env: Some("PROVIDER_HOST".to_string()),
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([
            ("PROVIDER_TOKEN".to_string(), token.to_string()),
            ("PROVIDER_HOST".to_string(), host_value.to_string()),
        ]);

        broker.virtualize_child_env(&mut env);

        match expected_host {
            Some(host) => {
                assert_ne!(env["PROVIDER_TOKEN"], token);
                assert!(broker.host_requires_mitm(host, /*port*/ 443));
                assert_eq!(
                    broker.environment(&env).binding_keys,
                    vec!["PROVIDER_HOST".to_string()]
                );
                assert_eq!(
                    broker.environment(&env).configured_provider_context_keys,
                    vec!["PROVIDER_HOST".to_string()]
                );
            }
            None => {
                assert_eq!(env["PROVIDER_TOKEN"], token);
                let mut snapshot = token.to_string();
                assert!(broker.virtualize_text(&mut snapshot, &env));
                assert_eq!(snapshot, token);
            }
        }
    }
}

#[test]
fn configured_provider_rejects_unsafe_destinations_and_unusable_dummy_patterns() {
    let impossible_assertion = CredentialProviderConfig {
        env: vec!["PROVIDER_PASSWORD".to_string()],
        patterns: vec![r"^pass_\b[a-z]{24}$".to_string()],
        url_prefixes: vec!["api.example".to_string()],
        ..CredentialProviderConfig::default()
    };
    assert!(
        super::configured::ConfiguredCredentialProvider::compile("custom", &impossible_assertion)
            .is_err()
    );

    for (pattern, url_prefixes, first, second) in [
        (
            r"\b|token_[a-z]{24}",
            vec!["api.example"],
            "token_abcdefghijklmnopqrstuvwx",
            None,
        ),
        (
            "provider_[a-z]{24}",
            vec!["*"],
            "provider_abcdefghijklmnopqrstuvwx",
            None,
        ),
        (
            "token_[01]",
            vec!["api.example"],
            "token_0",
            Some("token_1"),
        ),
        (
            "only_one_token",
            vec!["api.example"],
            "only_one_token",
            None,
        ),
    ] {
        let broker = broker_for(CredentialProviderConfig {
            env: vec!["FIRST_TOKEN".to_string(), "SECOND_TOKEN".to_string()],
            patterns: vec![pattern.to_string()],
            url_prefixes: url_prefixes.into_iter().map(str::to_string).collect(),
            ..CredentialProviderConfig::default()
        });
        let mut env = HashMap::from([("FIRST_TOKEN".to_string(), first.to_string())]);
        if let Some(second) = second {
            env.insert("SECOND_TOKEN".to_string(), second.to_string());
        }

        broker.virtualize_child_env(&mut env);

        assert_eq!(env["FIRST_TOKEN"], first);
        if let Some(second) = second {
            assert_eq!(env["SECOND_TOKEN"], second);
        }
        assert!(broker.environment(&env).credential_keys.is_empty());
        let mut snapshot = first.to_string();
        assert!(broker.virtualize_text(&mut snapshot, &env));
        assert_eq!(snapshot, first);
    }
}