product-os-request 0.0.55

// Integration tests for ProductOSRequest library
#![cfg(all(
    feature = "request_std",
    any(feature = "std", feature = "std_reqwest", feature = "std_hyper")
))]

use bytes::Bytes;
use product_os_http_body::BodyBytes;
use product_os_request::{
    Method, ProductOSClient, ProductOSRequestClient, ProductOSRequester, Protocol, RedirectPolicy,
};
use std::collections::BTreeMap;

#[test]
fn test_client_creation() {
    let client = ProductOSRequestClient::new();
    let _ = client.clone();
}

#[test]
fn test_requester_build_client() {
    let requester = ProductOSRequester::new();
    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_new_request_via_client() {
    let client = ProductOSRequestClient::new();
    let request = client.new_request(Method::GET, "http://example.com");
    let body = request.into_body();
    assert!(body.is_none(), "GET request should have no body by default");
}

#[test]
fn test_requester_with_custom_headers() {
    let mut requester = ProductOSRequester::new();
    requester.add_header("User-Agent", "TestBot/1.0", false);
    requester.add_header("Accept", "application/json", false);

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

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

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_requester_with_redirect_policy_none() {
    let mut requester = ProductOSRequester::new();
    requester.set_redirect_policy(RedirectPolicy::None);

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_requester_with_redirect_policy_limit() {
    let mut requester = ProductOSRequester::new();
    requester.set_redirect_policy(RedirectPolicy::Limit(3));

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_requester_with_proxy_http() {
    let mut requester = ProductOSRequester::new();
    requester.set_proxy(Some((Protocol::HTTP, String::from("127.0.0.1:8080"))));

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_request_builder_pattern() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::POST, "http://example.com/api");

    request.add_header("Content-Type", "application/json", false);
    request.bearer_auth(String::from("test_token"));
    request.add_param(String::from("key"), String::from("value"));

    let body = BodyBytes::new(Bytes::from(r#"{"test": "data"}"#));
    request.set_body(body);

    let extracted = request.into_body();
    assert!(extracted.is_some(), "Body should be present after set_body");
}

#[test]
fn test_request_with_multiple_params() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::GET, "http://example.com/search");

    let mut params = BTreeMap::new();
    params.insert(String::from("q"), String::from("rust"));
    params.insert(String::from("page"), String::from("1"));
    params.insert(String::from("per_page"), String::from("10"));
    params.insert(String::from("sort"), String::from("stars"));

    request.add_params(params);
}

#[test]
fn test_request_with_query_replacement() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::GET, "http://example.com");

    // Add initial params
    request.add_param(String::from("old"), String::from("value"));

    // Replace with new query
    let mut new_query = BTreeMap::new();
    new_query.insert(String::from("new"), String::from("value"));
    request.set_query(new_query);
}

#[test]
fn test_request_post_with_body() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::POST, "http://example.com/api/users");

    request.add_header("Content-Type", "application/json", false);
    let body = BodyBytes::new(Bytes::from(
        r#"{"name": "John", "email": "john@example.com"}"#,
    ));
    request.set_body(body);

    let extracted = request.into_body();
    assert!(extracted.is_some());
}

#[test]
fn test_request_put_with_body() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::PUT, "http://example.com/api/users/1");

    request.add_header("Content-Type", "application/json", false);
    let body = BodyBytes::new(Bytes::from(r#"{"name": "Jane Doe"}"#));
    request.set_body(body);

    let extracted = request.into_body();
    assert!(extracted.is_some());
}

#[test]
fn test_request_with_bearer_and_headers() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::GET, "http://example.com/api/protected");

    request.bearer_auth(String::from("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"));
    request.add_header("Accept", "application/json", false);
    request.add_header("X-Request-ID", "12345", false);
}

#[test]
fn test_requester_clone_and_modify() {
    let mut requester1 = ProductOSRequester::new();
    requester1.set_timeout(5000);

    let mut requester2 = requester1.clone();
    requester2.set_timeout(10000);

    // Both should be valid
    let mut client1 = ProductOSRequestClient::new();
    let mut client2 = ProductOSRequestClient::new();

    requester1.build(&mut client1);
    requester2.build(&mut client2);
}

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

    let mut client1 = ProductOSRequestClient::new();
    let mut client2 = ProductOSRequestClient::new();
    let mut client3 = ProductOSRequestClient::new();

    requester.build(&mut client1);
    requester.build(&mut client2);
    requester.build(&mut client3);
}

#[test]
fn test_request_empty_body_extraction() {
    let client = ProductOSRequestClient::new();
    let request = client.new_request(Method::GET, "http://example.com");
    let body = request.into_body();
    assert!(body.is_none());
}

#[test]
fn test_request_with_body_extraction() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::POST, "http://example.com");
    let body_bytes = BodyBytes::new(Bytes::from("test"));
    request.set_body(body_bytes);

    let extracted = request.into_body();
    assert!(extracted.is_some());
}

#[test]
fn test_client_clone() {
    let client1 = ProductOSRequestClient::new();
    let _client2 = client1.clone();
}

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

    // Configure all possible settings
    requester.force_secure(true);
    requester.set_timeout(30000);
    requester.set_connect_timeout(10000);
    requester.trust_all_certificates(false);
    requester.trust_any_certificate_for_hostname(false);
    requester.set_redirect_policy(RedirectPolicy::Limit(10));
    requester.add_header("User-Agent", "ProductOS-Request/0.0.54", false);

    let mut client = ProductOSRequestClient::new();
    requester.build(&mut client);
}

#[test]
fn test_request_with_complex_url() {
    let client = ProductOSRequestClient::new();
    let url = "https://api.example.com:8443/v2/users/search?existing=param";
    let mut request = client.new_request(Method::GET, url);

    request.add_param(String::from("new"), String::from("param"));
}

#[test]
fn test_multiple_header_additions() {
    let client = ProductOSRequestClient::new();
    let mut request = client.new_request(Method::GET, "http://example.com");

    for i in 0..10 {
        let key = format!("X-Custom-Header-{}", i);
        let value = format!("value-{}", i);
        request.add_header(&key, &value, false);
    }
}

#[test]
fn test_all_http_methods() {
    let client = ProductOSRequestClient::new();
    let methods = vec![
        Method::GET,
        Method::POST,
        Method::PUT,
        Method::PATCH,
        Method::DELETE,
        Method::HEAD,
        Method::OPTIONS,
        Method::TRACE,
        Method::CONNECT,
        Method::ANY,
    ];

    for method in methods {
        let request = client.new_request(method.clone(), "http://example.com");
        assert!(request.into_body().is_none());
    }
}