cs2-api 1.0.0

CS2 API client for Rust: Counter-Strike 2 live scores, match results, player stats, teams, rankings (world + VRS), events and skin prices
Documentation
//! Offline tests: a tiny std::net mock server stands in for the API. No network access.

use std::io::{BufRead, BufReader, Write};
use std::net::TcpListener;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

use cs2_api::{build_url, encode_segment, Client, Error};

struct Captured {
    request_line: String,
    headers: Vec<(String, String)>,
}

impl Captured {
    fn path(&self) -> &str {
        self.request_line.split(' ').nth(1).unwrap_or("")
    }

    fn header(&self, name: &str) -> Option<&str> {
        self.headers
            .iter()
            .find(|(k, _)| k.eq_ignore_ascii_case(name))
            .map(|(_, v)| v.as_str())
    }
}

/// Serves exactly one request with the given status and body, then reports what it saw.
fn serve_once(status: u16, body: &'static str) -> (String, mpsc::Receiver<Captured>) {
    let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
    let addr = listener.local_addr().unwrap();
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let (stream, _) = listener.accept().expect("accept");
        stream
            .set_read_timeout(Some(Duration::from_secs(5)))
            .unwrap();
        let mut reader = BufReader::new(stream.try_clone().unwrap());
        let mut request_line = String::new();
        reader.read_line(&mut request_line).unwrap();
        let mut headers = Vec::new();
        loop {
            let mut line = String::new();
            if reader.read_line(&mut line).unwrap() == 0 {
                break;
            }
            let line = line.trim_end();
            if line.is_empty() {
                break;
            }
            if let Some((k, v)) = line.split_once(':') {
                headers.push((k.trim().to_string(), v.trim().to_string()));
            }
        }
        let reason = if status == 200 { "OK" } else { "Error" };
        let response = format!(
            "HTTP/1.1 {status} {reason}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
            body.len()
        );
        let mut stream = stream;
        stream.write_all(response.as_bytes()).unwrap();
        stream.flush().unwrap();
        tx.send(Captured {
            request_line: request_line.trim_end().to_string(),
            headers,
        })
        .unwrap();
    });
    (format!("http://{addr}/api/v1"), rx)
}

fn client(base: &str) -> Client {
    Client::builder()
        .api_key("test-key")
        .base_url(base)
        .timeout(Duration::from_secs(5))
        .build()
        .expect("client")
}

fn recv(rx: &mpsc::Receiver<Captured>) -> Captured {
    rx.recv_timeout(Duration::from_secs(5)).expect("request")
}

#[test]
fn encodes_path_segments() {
    assert_eq!(encode_segment("vitality"), "vitality");
    assert_eq!(encode_segment("a b/c?d#e"), "a%20b%2Fc%3Fd%23e");
    assert_eq!(encode_segment("-_.~"), "-_.~");
    assert_eq!(encode_segment("é"), "%C3%A9");
}

#[test]
fn builds_urls_and_drops_empty_query_values() {
    assert_eq!(
        build_url("https://x.test/api/v1/", "/cs2/live", &[]),
        "https://x.test/api/v1/cs2/live"
    );
    assert_eq!(
        build_url("https://x.test/api/v1", "cs2/live", &[]),
        "https://x.test/api/v1/cs2/live"
    );
    assert_eq!(
        build_url(
            "https://x.test",
            "/cs2/skins/trending",
            &[("timeframe", "7d"), ("minPrice", ""), ("limit", "20")]
        ),
        "https://x.test/cs2/skins/trending?timeframe=7d&limit=20"
    );
    assert_eq!(
        build_url("https://x.test", "/cs2/search", &[("q", "team spirit&x")]),
        "https://x.test/cs2/search?q=team%20spirit%26x"
    );
}

#[test]
fn missing_key_is_an_error_with_signup_hint() {
    let err = Client::new("").unwrap_err();
    assert!(matches!(err, Error::MissingKey));
    assert!(err
        .to_string()
        .contains("Get a free key at https://cs2-api.org"));
}

#[test]
fn from_env_reads_cito_api_key() {
    std::env::set_var("CITO_API_KEY", "env-key");
    let ok = Client::from_env();
    std::env::remove_var("CITO_API_KEY");
    assert!(ok.is_ok());
    assert!(matches!(Client::from_env(), Err(Error::MissingKey)));
}

#[test]
fn default_base_url_and_debug_redacts_key() {
    let c = Client::new("secret").unwrap();
    assert_eq!(c.base_url(), "https://api.citoapi.com/api/v1");
    assert_eq!(c.timeout(), Duration::from_secs(20));
    assert!(!format!("{c:?}").contains("secret"));
}

#[test]
fn live_returns_data_and_sends_headers() {
    let (base, rx) = serve_once(
        200,
        r#"{"success":true,"data":[{"team1Name":"Vitality"}],"meta":{"total":1}}"#,
    );
    let data = client(&base).live().unwrap();
    assert_eq!(data[0]["team1Name"], "Vitality");
    let req = recv(&rx);
    assert_eq!(req.request_line, "GET /api/v1/cs2/live HTTP/1.1");
    assert_eq!(req.header("x-api-key"), Some("test-key"));
    assert_eq!(req.header("user-agent"), Some("cs2-api-rust/1.0.0"));
    assert_eq!(req.header("accept"), Some("application/json"));
}

#[test]
fn get_raw_returns_whole_envelope() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":[],"meta":{"page":2}}"#);
    let raw = client(&base)
        .get_raw("/cs2/matches/results", &[("page", "2")])
        .unwrap();
    assert_eq!(raw["meta"]["page"], 2);
    assert_eq!(recv(&rx).path(), "/api/v1/cs2/matches/results?page=2");
}

#[test]
fn path_segments_are_percent_encoded() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":{}}"#);
    client(&base).head_to_head("team a", "b/c").unwrap();
    assert_eq!(recv(&rx).path(), "/api/v1/cs2/teams/team%20a/h2h/b%2Fc");
}

#[test]
fn events_status_maps_to_path() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":[]}"#);
    client(&base).events("recent", 5).unwrap();
    assert_eq!(recv(&rx).path(), "/api/v1/cs2/events/recent?limit=5");

    let (base, rx) = serve_once(200, r#"{"success":true,"data":[]}"#);
    client(&base).events("whatever", 50).unwrap();
    assert_eq!(recv(&rx).path(), "/api/v1/cs2/events/upcoming?limit=50");
}

#[test]
fn trending_skins_query() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":{"gainers":[],"losers":[]}}"#);
    client(&base).trending_skins("7d", 20, Some(1.5)).unwrap();
    assert_eq!(
        recv(&rx).path(),
        "/api/v1/cs2/skins/trending?timeframe=7d&limit=20&minPrice=1.5"
    );

    let (base, rx) = serve_once(200, r#"{"success":true,"data":{}}"#);
    client(&base).trending_skins("24h", 10, None).unwrap();
    assert_eq!(
        recv(&rx).path(),
        "/api/v1/cs2/skins/trending?timeframe=24h&limit=10"
    );
}

#[test]
fn search_skins_with_filters() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":[]}"#);
    client(&base)
        .search_skins(None, &[("weapon", "AK-47"), ("skin_name", "Redline")])
        .unwrap();
    assert_eq!(
        recv(&rx).path(),
        "/api/v1/cs2/skins/search?weapon=AK-47&skin_name=Redline"
    );
}

#[test]
fn skin_history_optional_range() {
    let (base, rx) = serve_once(200, r#"{"success":true,"data":[]}"#);
    client(&base).skin_history("ak-47-redline", None).unwrap();
    assert_eq!(recv(&rx).path(), "/api/v1/cs2/skins/ak-47-redline/history");

    let (base, rx) = serve_once(200, r#"{"success":true,"data":[]}"#);
    client(&base)
        .skin_history("ak-47-redline", Some("30d"))
        .unwrap();
    assert_eq!(
        recv(&rx).path(),
        "/api/v1/cs2/skins/ak-47-redline/history?range=30d"
    );
}

#[test]
fn http_error_carries_status_code_and_message() {
    let (base, _rx) = serve_once(
        401,
        r#"{"success":false,"error":{"code":"INVALID_API_KEY","message":"Invalid API key"}}"#,
    );
    match client(&base).team("vitality").unwrap_err() {
        Error::Http {
            status,
            code,
            message,
        } => {
            assert_eq!(status, 401);
            assert_eq!(code.as_deref(), Some("INVALID_API_KEY"));
            assert_eq!(message, "Invalid API key");
        }
        other => panic!("unexpected error: {other:?}"),
    }
}

#[test]
fn http_error_without_json_body() {
    let (base, _rx) = serve_once(502, "bad gateway");
    match client(&base).today().unwrap_err() {
        Error::Http {
            status,
            code,
            message,
        } => {
            assert_eq!(status, 502);
            assert!(code.is_none());
            assert_eq!(message, "Request failed with status 502");
        }
        other => panic!("unexpected error: {other:?}"),
    }
}

#[test]
fn success_false_with_200_is_an_error() {
    let (base, _rx) = serve_once(
        200,
        r#"{"success":false,"error":{"code":"NOT_FOUND","message":"No such match"}}"#,
    );
    match client(&base).match_by_id("123").unwrap_err() {
        Error::Http { status, code, .. } => {
            assert_eq!(status, 200);
            assert_eq!(code.as_deref(), Some("NOT_FOUND"));
        }
        other => panic!("unexpected error: {other:?}"),
    }
}

#[test]
fn invalid_json_is_decode_error() {
    let (base, _rx) = serve_once(200, "not json");
    assert!(matches!(
        client(&base).world_ranking(10).unwrap_err(),
        Error::Decode(_)
    ));
}

#[test]
fn connection_refused_is_transport_error() {
    let port = {
        let l = TcpListener::bind("127.0.0.1:0").unwrap();
        l.local_addr().unwrap().port()
    };
    let c = client(&format!("http://127.0.0.1:{port}/api/v1"));
    let err = c.live().unwrap_err();
    assert!(matches!(err, Error::Transport(_)), "{err:?}");
    let _: &dyn std::error::Error = &err;
}