134 lines
4.3 KiB
Rust
134 lines
4.3 KiB
Rust
//! Peer client against a local HTTP listener.
|
|
//!
|
|
//! The listener is not a full `slinuxm`; it only has to speak enough HTTP/1.1
|
|
//! to prove the real transport. Later cases in this file drive a second
|
|
//! in-process server with fake sources.
|
|
|
|
use std::time::Duration;
|
|
|
|
use skyg_linux_tracker::peers::registry::ReqwestTransport;
|
|
use skyg_linux_tracker::peers::transport::{PeerBody, PeerRequest, PeerTransport};
|
|
use skyg_linux_tracker::peers::types::{PeerConfig, PeerName, PeersConfig};
|
|
use skyg_linux_tracker::peers::PeerError;
|
|
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
|
use tokio::net::TcpListener;
|
|
|
|
fn transport() -> ReqwestTransport {
|
|
ReqwestTransport::new(&PeersConfig {
|
|
enabled: true,
|
|
max_response_bytes: 64,
|
|
..PeersConfig::default()
|
|
})
|
|
.unwrap()
|
|
}
|
|
|
|
fn peer(port: u16, token: &std::path::Path) -> PeerConfig {
|
|
PeerConfig {
|
|
name: PeerName::parse("beta").unwrap(),
|
|
url: url::Url::parse(&format!("http://127.0.0.1:{port}")).unwrap(),
|
|
token_file: token.to_path_buf(),
|
|
ca_file: None,
|
|
allow_plain_http: false,
|
|
enabled: true,
|
|
}
|
|
}
|
|
|
|
fn token_file(contents: &str) -> std::path::PathBuf {
|
|
use std::io::Write;
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
let path = std::env::temp_dir().join(format!(
|
|
"slinuxm-peers-reg-{}-{}",
|
|
std::process::id(),
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos()
|
|
));
|
|
std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(true)
|
|
.mode(0o600)
|
|
.open(&path)
|
|
.unwrap()
|
|
.write_all(contents.as_bytes())
|
|
.unwrap();
|
|
path
|
|
}
|
|
|
|
fn ping() -> PeerRequest {
|
|
PeerRequest {
|
|
path: "/api/v1/ping".into(),
|
|
query: vec![],
|
|
headers: vec![],
|
|
accept: None,
|
|
}
|
|
}
|
|
|
|
async fn read_head(sock: &mut tokio::net::TcpStream) -> String {
|
|
let mut buf = Vec::new();
|
|
let mut tmp = [0u8; 512];
|
|
while !buf.windows(4).any(|w| w == b"\r\n\r\n") {
|
|
let n = tokio::time::timeout(Duration::from_secs(2), sock.read(&mut tmp))
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
if n == 0 {
|
|
break;
|
|
}
|
|
buf.extend_from_slice(&tmp[..n]);
|
|
}
|
|
String::from_utf8_lossy(&buf).into_owned()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn client_get_is_capped_and_does_not_follow_redirects() {
|
|
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let port = listener.local_addr().unwrap().port();
|
|
let token = token_file("fixture-token\n");
|
|
tokio::spawn(async move {
|
|
let (mut sock, _) = listener.accept().await.unwrap();
|
|
let head = read_head(&mut sock).await;
|
|
assert!(head.starts_with("GET /api/v1/ping HTTP/1.1"));
|
|
assert!(head
|
|
.to_ascii_lowercase()
|
|
.contains("authorization: bearer fixture-token"));
|
|
let body = "0123456789abcdef";
|
|
let resp = format!(
|
|
"HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:1/nope\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
|
body.len()
|
|
);
|
|
let _ = sock.write_all(resp.as_bytes()).await;
|
|
});
|
|
|
|
let resp = transport()
|
|
.get(&peer(port, &token), ping(), Duration::from_secs(2))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status, 302);
|
|
match resp.body {
|
|
PeerBody::Bytes(b) => assert_eq!(&b[..], b"0123456789abcdef"),
|
|
PeerBody::Stream(_) => panic!("expected a buffered body"),
|
|
}
|
|
|
|
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let port = listener.local_addr().unwrap().port();
|
|
tokio::spawn(async move {
|
|
let (mut sock, _) = listener.accept().await.unwrap();
|
|
let _ = read_head(&mut sock).await;
|
|
let mut resp =
|
|
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n".to_vec();
|
|
let chunk = vec![b'z'; 200];
|
|
resp.extend(format!("{:x}\r\n", chunk.len()).into_bytes());
|
|
resp.extend_from_slice(&chunk);
|
|
resp.extend(b"\r\n0\r\n\r\n");
|
|
let _ = sock.write_all(&resp).await;
|
|
});
|
|
let err = transport()
|
|
.get(&peer(port, &token), ping(), Duration::from_secs(2))
|
|
.await
|
|
.unwrap_err();
|
|
assert!(matches!(err, PeerError::Oversize), "{err:?}");
|
|
let _ = std::fs::remove_file(&token);
|
|
}
|