mod.rs

pub mod lighter_helpers;
pub mod extended_helpers;

#[allow(unused_imports)]
pub use std::time::Duration;

/// Exchange endpoint URLs for integration tests. Thin wrapper around the
/// compile-time constants in `arb_common::constants::*`. Kept as a struct
/// instead of raw `&'static str` consts so test files stay uncoupled from
/// the exact constant names (e.g. switching from mainnet to a future
/// testnet URL set requires one change here, not per-test).
pub struct TestUrls {
    pub lighter_rest: String,
    pub lighter_ws: String,
    pub extended_rest: String,
    pub extended_ws_orderbook: String,
    pub extended_ws_account: String,
    pub extended_ws_public_trades: String,
}

impl TestUrls {
    pub fn load() -> Self {
        Self {
            lighter_rest: arb_common::constants::LIGHTER_REST_URL.to_string(),
            lighter_ws: arb_common::constants::LIGHTER_WS_URL.to_string(),
            extended_rest: arb_common::constants::EXTENDED_REST_URL.to_string(),
            extended_ws_orderbook: arb_common::constants::EXTENDED_WS_ORDERBOOK_URL.to_string(),
            extended_ws_account: arb_common::constants::EXTENDED_WS_ACCOUNT_URL.to_string(),
            extended_ws_public_trades: arb_common::constants::EXTENDED_WS_PUBLIC_TRADES_URL.to_string(),
        }
    }
}

pub fn load_env() {
    // Ensure working directory is the project root (parent of bot/) so that
    // relative paths like "db/arb_bot.db" and "config/" resolve correctly,
    // regardless of where `cargo test` sets cwd.
    let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let project_root = manifest.parent().unwrap_or(&manifest);
    let _ = std::env::set_current_dir(project_root);

    let path = std::path::Path::new(".env");
    if !path.exists() {
        panic!(".env file not found at {} — cannot run integration tests", project_root.display());
    }
    let path = path.to_path_buf();
    for line in std::fs::read_to_string(path).unwrap().lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        if let Some((key, val)) = line.split_once('=')
            && std::env::var(key.trim()).is_err() {
                unsafe { std::env::set_var(key.trim(), val.trim()) };
            }
    }
}

/// Load native root certificates with retry (macOS keychain can transiently fail).
fn build_test_root_store() -> tokio_rustls::rustls::RootCertStore {
    let mut root_store = tokio_rustls::rustls::RootCertStore::empty();
    let mut certs = None;
    for attempt in 1..=3 {
        match rustls_native_certs::load_native_certs() {
            Ok(c) => { certs = Some(c); break; }
            Err(e) => {
                eprintln!("load_native_certs attempt {attempt}/3 failed: {e}");
                std::thread::sleep(std::time::Duration::from_secs(1));
            }
        }
    }
    for cert in certs.expect("load_native_certs failed after 3 attempts") {
        root_store.add(cert).ok();
    }
    root_store
}

pub fn build_test_tls_connector() -> tokio_rustls::TlsConnector {
    let root_store = build_test_root_store();
    let config = tokio_rustls::rustls::ClientConfig::builder()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    tokio_rustls::TlsConnector::from(std::sync::Arc::new(config))
}

pub async fn connect_test_wss(
    url: &str,
    extra_headers: &[(&str, &str)],
    connector: &tokio_rustls::TlsConnector,
) -> anyhow::Result<fastwebsockets::FragmentCollector<hyper_util::rt::TokioIo<hyper::upgrade::Upgraded>>> {
    let parsed = url::Url::parse(url).map_err(|e| anyhow::anyhow!("bad url: {e}"))?;
    let host = parsed.host_str().ok_or_else(|| anyhow::anyhow!("no host"))?;
    let port = parsed.port().unwrap_or(443);

    let tcp = tokio::net::TcpStream::connect(format!("{host}:{port}")).await?;
    tcp.set_nodelay(true)?;
    let server_name = tokio_rustls::rustls::pki_types::ServerName::try_from(host.to_string())?;
    let tls = connector.connect(server_name, tcp).await?;

    let mut req = hyper::Request::builder()
        .method("GET")
        .uri(url)
        .header("Host", host)
        .header("Connection", "Upgrade")
        .header("Upgrade", "websocket")
        .header("Sec-WebSocket-Version", "13")
        .header("Sec-WebSocket-Key", fastwebsockets::handshake::generate_key())
        .header("User-Agent", "arb_bot/test");

    for (name, value) in extra_headers {
        req = req.header(*name, *value);
    }

    struct Exec;
    impl<F: std::future::Future<Output = ()> + Send + 'static> hyper::rt::Executor<F> for Exec {
        fn execute(&self, fut: F) { tokio::spawn(fut); }
    }

    let (ws, _) = fastwebsockets::handshake::client(
        &Exec,
        req.body(http_body_util::Empty::<bytes::Bytes>::new())?,
        Box::pin(tls),
    ).await?;

    Ok(fastwebsockets::FragmentCollector::new(ws))
}

pub fn build_test_https_client() -> hyper_util::client::legacy::Client<
    hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>,
    http_body_util::Full<bytes::Bytes>,
> {
    // Reuse root store with retry logic from build_test_tls_connector
    let root_store = build_test_root_store();
    let config = tokio_rustls::rustls::ClientConfig::builder()
        .with_root_certificates(root_store)
        .with_no_client_auth();
    let https = hyper_rustls::HttpsConnectorBuilder::new()
        .with_tls_config(config)
        .https_only()
        .enable_http1()
        .build();
    hyper_util::client::legacy::Client::builder(
        hyper_util::rt::TokioExecutor::new(),
    ).build(https)
}

pub async fn http_get_test(
    url: &str,
    headers: &[(&str, &str)],
    connector: &tokio_rustls::TlsConnector,
) -> anyhow::Result<Vec<u8>> {
    let parsed = url::Url::parse(url).map_err(|e| anyhow::anyhow!("bad url: {e}"))?;
    let host = parsed.host_str().ok_or_else(|| anyhow::anyhow!("no host"))?;
    let port = parsed.port().unwrap_or(443);
    let path = if parsed.query().is_some() {
        format!("{}?{}", parsed.path(), parsed.query().unwrap())
    } else {
        parsed.path().to_string()
    };

    let tcp = tokio::net::TcpStream::connect(format!("{host}:{port}")).await?;
    tcp.set_nodelay(true)?;
    let server_name = tokio_rustls::rustls::pki_types::ServerName::try_from(host.to_string())?;
    let tls = connector.connect(server_name, tcp).await?;
    let io = hyper_util::rt::TokioIo::new(Box::pin(tls));

    let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await?;
    tokio::spawn(async move { let _ = conn.await; });

    let mut req = hyper::Request::builder()
        .method("GET")
        .uri(&path)
        .header("Host", host)
        .header("User-Agent", "arb_bot/test");

    for (name, value) in headers {
        req = req.header(*name, *value);
    }

    use http_body_util::BodyExt;
    let resp = sender.send_request(req.body(http_body_util::Empty::<bytes::Bytes>::new())?).await?;
    let body = resp.into_body().collect().await?.to_bytes();
    Ok(body.to_vec())
}

/// POST with JSON body for testing. Used by Hyperliquid `/info` probes.
pub async fn http_post_json_test(
    url: &str,
    json_body: &str,
    connector: &tokio_rustls::TlsConnector,
) -> anyhow::Result<Vec<u8>> {
    let parsed = url::Url::parse(url).map_err(|e| anyhow::anyhow!("bad url: {e}"))?;
    let host = parsed.host_str().ok_or_else(|| anyhow::anyhow!("no host"))?;
    let port = parsed.port().unwrap_or(443);
    let path = parsed.path().to_string();

    let tcp = tokio::net::TcpStream::connect(format!("{host}:{port}")).await?;
    tcp.set_nodelay(true)?;
    let server_name = tokio_rustls::rustls::pki_types::ServerName::try_from(host.to_string())?;
    let tls = connector.connect(server_name, tcp).await?;
    let io = hyper_util::rt::TokioIo::new(Box::pin(tls));

    let (mut sender, conn) = hyper::client::conn::http1::handshake(io).await?;
    tokio::spawn(async move { let _ = conn.await; });

    let req = hyper::Request::builder()
        .method("POST")
        .uri(&path)
        .header("Host", host)
        .header("User-Agent", "arb_bot/test")
        .header("Content-Type", "application/json")
        .body(http_body_util::Full::new(bytes::Bytes::from(json_body.to_string())))?;

    use http_body_util::BodyExt;
    let resp = sender.send_request(req).await?;
    let body = resp.into_body().collect().await?.to_bytes();
    Ok(body.to_vec())
}

pub async fn extended_api_get(
    client: &hyper_util::client::legacy::Client<
        hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>,
        http_body_util::Full<bytes::Bytes>,
    >,
    rest_url: &str,
    path: &str,
    api_key: &str,
) -> Vec<u8> {
    let url = format!("{rest_url}{path}");
    let req = hyper::Request::builder()
        .method("GET")
        .uri(&url)
        .header("X-Api-Key", api_key)
        .header("User-Agent", "arb_bot/test")
        .body(http_body_util::Full::new(bytes::Bytes::new()))
        .unwrap();
    let resp = client.request(req).await.expect("GET request failed");
    use http_body_util::BodyExt;
    resp.into_body().collect().await.unwrap().to_bytes().to_vec()
}

pub async fn extended_api_post(
    client: &hyper_util::client::legacy::Client<
        hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>,
        http_body_util::Full<bytes::Bytes>,
    >,
    rest_url: &str,
    path: &str,
    api_key: &str,
    body: &str,
) -> Vec<u8> {
    let url = format!("{rest_url}{path}");
    let req = hyper::Request::builder()
        .method("POST")
        .uri(&url)
        .header("X-Api-Key", api_key)
        .header("Content-Type", "application/json")
        .header("User-Agent", "arb_bot/test")
        .body(http_body_util::Full::new(bytes::Bytes::from(body.to_owned())))
        .unwrap();
    let resp = client.request(req).await.expect("POST request failed");
    use http_body_util::BodyExt;
    resp.into_body().collect().await.unwrap().to_bytes().to_vec()
}

pub async fn extended_api_delete(
    client: &hyper_util::client::legacy::Client<
        hyper_rustls::HttpsConnector<hyper_util::client::legacy::connect::HttpConnector>,
        http_body_util::Full<bytes::Bytes>,
    >,
    rest_url: &str,
    path: &str,
    api_key: &str,
) -> Vec<u8> {
    let url = format!("{rest_url}{path}");
    let req = hyper::Request::builder()
        .method("DELETE")
        .uri(&url)
        .header("X-Api-Key", api_key)
        .header("User-Agent", "arb_bot/test")
        .body(http_body_util::Full::new(bytes::Bytes::new()))
        .unwrap();
    let resp = client.request(req).await.expect("DELETE request failed");
    use http_body_util::BodyExt;
    resp.into_body().collect().await.unwrap().to_bytes().to_vec()
}