product-os-request 0.0.55

// Test suite for ProductOSRequester configuration
#![cfg(any(feature = "request", feature = "request_std"))]

use product_os_request::{ProductOSRequester, Protocol, RedirectPolicy};
use std::collections::BTreeMap;

#[test]
fn test_requester_new() {
    let requester = ProductOSRequester::new();
    assert_eq!(requester.trusted_certificates().len(), 0);
}

#[test]
fn test_requester_add_header() {
    let mut requester = ProductOSRequester::new();
    requester.add_header("User-Agent", "TestBot/1.0", false);
    requester.add_header("X-Custom-Header", "value", false);
    // Headers are stored internally; no panic means success
}

#[test]
fn test_requester_set_headers() {
    let mut requester = ProductOSRequester::new();

    let mut headers = BTreeMap::new();
    headers.insert(String::from("Accept"), String::from("application/json"));
    headers.insert(String::from("Accept-Language"), String::from("en-US"));

    requester.set_headers(headers);
}

#[test]
fn test_requester_force_secure() {
    let mut requester = ProductOSRequester::new();
    requester.force_secure(true);
    requester.force_secure(false);
}

#[test]
fn test_requester_trust_all_certificates() {
    let mut requester = ProductOSRequester::new();
    requester.trust_all_certificates(true);
    requester.trust_all_certificates(false);
}

#[test]
fn test_requester_trust_any_certificate_for_hostname() {
    let mut requester = ProductOSRequester::new();
    requester.trust_any_certificate_for_hostname(true);
    requester.trust_any_certificate_for_hostname(false);
}

#[test]
fn test_requester_set_timeout() {
    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000);
    requester.set_timeout(10000);
    requester.set_timeout(30000);
}

#[test]
fn test_requester_set_connect_timeout() {
    let mut requester = ProductOSRequester::new();
    requester.set_connect_timeout(2000);
    requester.set_connect_timeout(5000);
    requester.set_connect_timeout(10000);
}

#[test]
fn test_requester_add_trusted_certificate_der() {
    let mut requester = ProductOSRequester::new();
    let cert = vec![0u8; 100];
    requester.add_trusted_certificate_der(cert);
    assert_eq!(requester.trusted_certificates().len(), 1);
}

#[test]
fn test_requester_trusted_certificates() {
    let mut requester = ProductOSRequester::new();

    let cert1 = vec![1u8; 50];
    let cert2 = vec![2u8; 75];

    requester.add_trusted_certificate_der(cert1.clone());
    requester.add_trusted_certificate_der(cert2.clone());

    let certs = requester.trusted_certificates();
    assert_eq!(certs.len(), 2);
    assert_eq!(certs[0], cert1);
    assert_eq!(certs[1], cert2);
}

#[test]
fn test_requester_set_redirect_policy() {
    let mut requester = ProductOSRequester::new();

    requester.set_redirect_policy(RedirectPolicy::None);
    requester.set_redirect_policy(RedirectPolicy::Default);
    requester.set_redirect_policy(RedirectPolicy::Limit(5));
    requester.set_redirect_policy(RedirectPolicy::Limit(10));
}

#[test]
fn test_requester_set_proxy_none() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(None);
}

#[test]
fn test_requester_set_proxy_http() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(Some((
        Protocol::HTTP,
        String::from("proxy.example.com:8080"),
    )));
}

#[test]
fn test_requester_set_proxy_https() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(Some((
        Protocol::HTTPS,
        String::from("proxy.example.com:443"),
    )));
}

#[test]
fn test_requester_set_proxy_socks5() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(Some((
        Protocol::SOCKS5,
        String::from("socks.example.com:1080"),
    )));
}

#[test]
fn test_requester_set_proxy_all() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(Some((
        Protocol::ALL,
        String::from("proxy.example.com:8080"),
    )));
}

#[test]
fn test_requester_clone() {
    let mut requester = ProductOSRequester::new();
    requester.set_timeout(5000);
    requester.force_secure(true);
    requester.add_trusted_certificate_der(vec![42u8; 10]);

    let cloned = requester.clone();
    assert_eq!(cloned.trusted_certificates().len(), 1);
    assert_eq!(cloned.trusted_certificates()[0], vec![42u8; 10]);
}

#[test]
fn test_requester_multiple_certificates() {
    let mut requester = ProductOSRequester::new();

    for i in 0..5 {
        let cert = vec![i; 100];
        requester.add_trusted_certificate_der(cert);
    }

    let certs = requester.trusted_certificates();
    assert_eq!(certs.len(), 5);
    for (i, cert) in certs.iter().enumerate() {
        assert_eq!(cert[0], i as u8);
    }
}

#[test]
fn test_requester_configuration_chain() {
    let mut requester = ProductOSRequester::new();

    requester.force_secure(true);
    requester.set_timeout(10000);
    requester.set_connect_timeout(5000);
    requester.trust_all_certificates(false);
    requester.set_redirect_policy(RedirectPolicy::Limit(5));
    requester.add_header("User-Agent", "TestBot/1.0", false);
}

#[test]
fn test_requester_empty_headers() {
    let mut requester = ProductOSRequester::new();
    let empty = BTreeMap::new();
    requester.set_headers(empty);
}

#[test]
fn test_requester_sensitive_headers() {
    let mut requester = ProductOSRequester::new();
    requester.add_header("Authorization", "Bearer token", true);
    requester.add_header("X-Api-Key", "secret", true);
}

#[allow(deprecated)]
#[test]
fn test_deprecated_pem_method_still_works() {
    let mut requester = ProductOSRequester::new();
    requester.add_trusted_certificate_pem(vec![1u8; 50]);
    assert_eq!(requester.trusted_certificates().len(), 1);
}
#[allow(deprecated)]
#[test]
fn test_deprecated_get_trusted_certificates_still_works() {
    let mut requester = ProductOSRequester::new();
    requester.add_trusted_certificate_der(vec![1u8; 50]);
    let certs = requester.get_trusted_certificates();
    assert_eq!(certs.len(), 1);
}