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())
}
}
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;
}