use std::io::{BufRead, BufReader, Read, Write};
use std::net::TcpListener;
use townos_api::Client;
struct Seen {
method: String,
target: String,
authorization: Option<String>,
content_type: Option<String>,
body: String,
}
impl Seen {
fn json(&self) -> serde_json::Value {
serde_json::from_str(&self.body)
.unwrap_or_else(|e| panic!("body is not JSON ({e}): {:?}", self.body))
}
}
struct OneShot {
host: String,
handle: std::thread::JoinHandle<Seen>,
}
impl OneShot {
fn seen(self) -> Seen {
self.handle.join().expect("the server thread panicked")
}
}
fn serve(status: u16, response: &str) -> OneShot {
serve_bytes(status, "application/json", response.as_bytes().to_vec())
}
fn serve_bytes(status: u16, content_type: &str, response: Vec<u8>) -> OneShot {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind a loopback port");
let host = format!("127.0.0.1:{}", listener.local_addr().unwrap().port());
let content_type = content_type.to_owned();
let handle = std::thread::spawn(move || {
let (stream, _) = listener.accept().expect("accept");
let mut reader = BufReader::new(stream);
let mut request_line = String::new();
reader.read_line(&mut request_line).expect("read the request line");
let mut parts = request_line.split_whitespace();
let method = parts.next().unwrap_or_default().to_owned();
let target = parts.next().unwrap_or_default().to_owned();
let mut length = 0usize;
let mut chunked = false;
let mut authorization = None;
let mut content_type_seen = None;
loop {
let mut line = String::new();
reader.read_line(&mut line).expect("read a header");
let line = line.trim_end();
if line.is_empty() {
break;
}
let (name, value) = line.split_once(':').unwrap_or((line, ""));
let value = value.trim().to_owned();
match name.to_ascii_lowercase().as_str() {
"content-length" => length = value.parse().unwrap_or(0),
"transfer-encoding" if value.eq_ignore_ascii_case("chunked") => chunked = true,
"authorization" => authorization = Some(value),
"content-type" => content_type_seen = Some(value),
_ => {}
}
}
let mut body = Vec::new();
if chunked {
loop {
let mut size_line = String::new();
reader.read_line(&mut size_line).expect("read a chunk size");
let size = usize::from_str_radix(size_line.trim().split(';').next().unwrap_or("0"), 16)
.unwrap_or(0);
if size == 0 {
break;
}
let mut chunk = vec![0u8; size];
reader.read_exact(&mut chunk).expect("read a chunk");
body.extend_from_slice(&chunk);
let mut crlf = [0u8; 2];
reader.read_exact(&mut crlf).expect("read the chunk terminator");
}
} else if length > 0 {
body = vec![0u8; length];
reader.read_exact(&mut body).expect("read the body");
}
let reason = if status == 200 { "OK" } else { "Error" };
let head = format!(
"HTTP/1.1 {status} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
response.len()
);
let mut stream = reader.into_inner();
stream.write_all(head.as_bytes()).expect("write the head");
stream.write_all(&response).expect("write the body");
stream.flush().expect("flush");
Seen {
method,
target,
authorization,
content_type: content_type_seen,
body: String::from_utf8_lossy(&body).into_owned(),
}
});
OneShot { host, handle }
}
fn client(server: &OneShot) -> Client {
let client = Client::new(&server.host).expect("build a client");
client.set_token("a.token");
client
}
#[tokio::test]
async fn authenticate_posts_credentials_and_keeps_the_token() {
let server = serve(200, r#"{"token":"issued.jwt.here"}"#);
let c = Client::new(&server.host).unwrap();
let out = c.authenticate("erikh", "hunter2").await.unwrap();
let seen = server.seen();
assert_eq!(seen.method, "POST");
assert_eq!(seen.target, "/account/authenticate");
assert_eq!(seen.json()["username"], "erikh");
assert_eq!(seen.json()["password"], "hunter2");
assert_eq!(seen.authorization, None);
assert_eq!(out.token, "issued.jwt.here");
assert_eq!(c.token().as_deref(), Some("issued.jwt.here"), "the token is stored");
}
#[tokio::test]
async fn whoami_reads_the_username_out_of_account_me() {
let server = serve(200, r#"{"username":"erikh"}"#);
let username = client(&server).whoami().await.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("GET", "/account/me"));
assert_eq!(seen.authorization.as_deref(), Some("Bearer a.token"));
assert_eq!(username, "erikh");
}
#[tokio::test]
async fn whoami_without_a_token_never_reaches_the_box() {
let c = Client::new("127.0.0.1:9").unwrap();
let err = c.whoami().await.unwrap_err();
assert!(err.is_unauthenticated());
assert_eq!(err.http_status(), None, "nothing was sent");
}
#[tokio::test]
async fn sessions_are_listed_with_their_timestamps() {
let server = serve(
200,
r#"[{"id":"sess-1","username":"erikh","created_at":"2026-08-01T10:00:00Z","last_used":"2026-08-12T09:30:00Z"}]"#,
);
let sessions = client(&server).sessions().await.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("GET", "/account/sessions"));
assert_eq!(sessions.len(), 1);
assert_eq!(sessions[0].id, "sess-1");
assert!(sessions[0].created_at.is_some());
assert!(sessions[0].last_used.is_some());
}
#[tokio::test]
async fn revoking_a_session_names_it() {
let server = serve(200, r#"{"status":"ok"}"#);
client(&server).revoke_session("sess-1").await.unwrap();
let seen = server.seen();
assert_eq!(seen.method, "POST");
assert_eq!(seen.target, "/account/session/revoke");
assert_eq!(seen.json()["session_id"], "sess-1");
}
#[tokio::test]
async fn the_account_is_fetched_by_post_with_its_username() {
let server = serve(
200,
r#"{"username":"erikh","admin":false,"grants":["wireguard"],"networks":["office"]}"#,
);
let account = client(&server).account("erikh").await.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/account"));
assert_eq!(seen.json()["username"], "erikh");
assert!(!account.admin);
assert!(account.holds("wireguard"));
assert!(!account.holds("gfeh"));
assert!(account.may_use_network("office"));
assert!(!account.may_use_network("home"));
}
#[tokio::test]
async fn a_details_change_sends_only_the_fields_that_changed() {
let server = serve(200, r#"{"username":"erikh","email":"new@example.com"}"#);
let details = townos_api::AccountDetails {
email: Some("new@example.com".into()),
..Default::default()
};
let account = client(&server)
.update_details("erikh", details)
.await
.unwrap()
.expect("an update with a field in it returns the new account");
assert_eq!(account.email, "new@example.com");
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/account/update"));
let body = seen.json();
assert_eq!(body["username"], "erikh");
assert_eq!(body["fields"]["email"], "new@example.com");
for untouched in ["phone", "real_name", "password", "admin", "grants", "networks"] {
assert!(
body["fields"].get(untouched).is_none(),
"{untouched} must not be sent when it did not change"
);
}
}
#[tokio::test]
async fn clearing_a_detail_sends_it_as_empty_rather_than_omitting_it() {
let server = serve(200, r#"{"username":"erikh"}"#);
let details = townos_api::AccountDetails {
phone: Some(String::new()),
..Default::default()
};
client(&server).update_details("erikh", details).await.unwrap();
let body = server.seen().json();
assert_eq!(body["fields"]["phone"], "");
}
#[tokio::test]
async fn a_password_change_is_an_account_update_with_only_that_field() {
let server = serve(200, r#"{"username":"erikh"}"#);
client(&server).set_password("erikh", "a-new-password").await.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/account/update"));
let body = seen.json();
assert_eq!(body["username"], "erikh");
assert_eq!(body["fields"]["password"], "a-new-password");
for untouched in ["admin", "grants", "networks", "email", "phone", "real_name"] {
assert!(
body["fields"].get(untouched).is_none(),
"{untouched} must not be sent by a password change"
);
}
}
#[tokio::test]
async fn ping_needs_no_token_and_reports_needs_setup() {
let server = serve(
200,
r#"{"status":"ok","installed":4,"accounts":1,"needs_setup":true,"units":{"total":9,"running":8,"failed":1}}"#,
);
let ping = Client::new(&server.host).unwrap().ping().await.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("GET", "/status/ping"));
assert_eq!(seen.authorization, None, "the sign-in screen probes without one");
assert!(ping.needs_setup);
assert_eq!(ping.installed, 4);
assert_eq!(ping.units.unwrap().failed, 1);
}
#[tokio::test]
async fn system_services_decode_the_capitalised_systemd_fields() {
let server = serve(
200,
r#"[{"key":"rolodex","display_name":"DNS","image":"img:1","Name":"rolodex.service","ActiveState":"active","SubState":"running"}]"#,
);
let services = client(&server).system_services().await.unwrap();
assert_eq!(server.seen().target, "/system-services");
assert_eq!(services[0].unit_name, "rolodex.service");
assert_eq!(services[0].sub_state, "running");
assert!(services[0].running());
assert_eq!(services[0].label(), "DNS");
}
#[tokio::test]
async fn a_service_action_sends_the_key_and_the_verb() {
let server = serve(200, "");
client(&server).set_system_service("rolodex", "restart").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/system-services/status");
assert_eq!(seen.json()["key"], "rolodex");
assert_eq!(seen.json()["action"], "restart");
}
#[tokio::test]
async fn dns_status_keeps_what_was_asked_for_apart_from_what_is_in_effect() {
let server = serve(
200,
r#"{"enabled":true,"running":true,"tld":"home.town","record_count":42,
"local_forwarders":true,"forwarders":["1.1.1.1","8.8.8.8"]}"#,
);
let status = client(&server).dns_status().await.unwrap();
assert_eq!(server.seen().target, "/dns/status");
assert!(status.running);
assert_eq!(status.tld, "home.town");
assert_eq!(status.record_count, 42);
assert!(status.local_forwarders, "what the operator asked for");
assert_eq!(
status.forwarders,
vec!["1.1.1.1".to_string(), "8.8.8.8".to_string()],
"what rolodex.yml actually holds"
);
}
#[tokio::test]
async fn dns_services_report_whether_each_is_published() {
let server = serve(
200,
r#"[{"repo":"core","name":"gitea","version":"1.24","fqdn":"gitea.home.town","domains":["home.town"],"published":true},
{"repo":"core","name":"mail","version":"2.0","fqdn":"mail.home.town","published":false}]"#,
);
let services = client(&server).dns_services().await.unwrap();
assert_eq!(server.seen().target, "/dns/services");
assert_eq!(services.len(), 2);
assert!(services[0].published);
assert_eq!(services[0].fqdn, "gitea.home.town");
assert!(!services[1].published);
assert!(services[1].domains.is_empty(), "an absent list is empty, not an error");
}
#[tokio::test]
async fn records_span_every_zone_unless_a_tld_is_given() {
let server = serve(200, "[]");
client(&server).dns_records(None).await.unwrap();
assert_eq!(server.seen().target, "/dns/records");
let server = serve(200, "[]");
client(&server).dns_records(Some("home.town")).await.unwrap();
assert_eq!(server.seen().target, "/dns/records?tld=home.town");
let server = serve(200, "[]");
client(&server).dns_records(Some("")).await.unwrap();
assert_eq!(server.seen().target, "/dns/records");
}
#[tokio::test]
async fn a_tld_is_escaped_into_the_query_string() {
let server = serve(200, "[]");
client(&server).dns_records(Some("a b&tld=x")).await.unwrap();
assert_eq!(server.seen().target, "/dns/records?tld=a%20b%26tld%3Dx");
}
#[tokio::test]
async fn a_record_is_added_with_its_type_as_a_number() {
use townos_api::dns::RecordType;
let server = serve(200, "");
client(&server)
.add_dns_record("app.home.town", RecordType::CNAME, "other.home.town", 300)
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/records/add");
let body = seen.json();
assert_eq!(body["name"], "app.home.town");
assert_eq!(body["value"], "other.home.town");
assert_eq!(body["ttl"], 300);
assert_eq!(body["record_type"], 2);
}
#[tokio::test]
async fn removing_a_record_identifies_it_by_name_and_type() {
use townos_api::dns::RecordType;
let server = serve(200, "");
client(&server)
.remove_dns_record("app.home.town", RecordType::A)
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/records/remove");
assert_eq!(seen.json()["name"], "app.home.town");
assert_eq!(seen.json()["record_type"], 0, "A is zero, not absent");
}
#[tokio::test]
async fn the_tld_is_unwrapped_from_its_object() {
let server = serve(200, r#"{"tld":"home.town"}"#);
assert_eq!(client(&server).dns_tld().await.unwrap(), "home.town");
assert_eq!(server.seen().target, "/dns/tld");
let server = serve(200, "");
client(&server).set_dns_tld("home.town").await.unwrap();
assert_eq!(server.seen().json()["tld"], "home.town");
}
#[tokio::test]
async fn dns_setup_posts_an_empty_object_not_an_empty_body() {
let server = serve(200, "");
client(&server).setup_dns().await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/setup");
assert_eq!(seen.body, "{}");
assert_eq!(seen.content_type.as_deref(), Some("application/json"));
}
#[tokio::test]
async fn publishing_a_service_names_its_repo() {
let server = serve(200, "");
client(&server).set_dns_service("core", "gitea", true).await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/services/set");
assert_eq!(seen.json()["repo"], "core");
assert_eq!(seen.json()["name"], "gitea");
assert_eq!(seen.json()["published"], true);
}
#[tokio::test]
async fn the_two_blocklists_are_separate_paths() {
use townos_api::dns::Blocklist;
let server = serve(200, r#"{"enabled":true,"providers":[]}"#);
client(&server).blocklist_config(Blocklist::Rbl).await.unwrap();
assert_eq!(server.seen().target, "/dns/rbl");
let server = serve(200, r#"{"enabled":true,"providers":[]}"#);
client(&server).blocklist_config(Blocklist::Dnsbl).await.unwrap();
assert_eq!(server.seen().target, "/dns/dnsbl");
}
#[tokio::test]
async fn a_blocklist_config_is_replaced_wholesale() {
use townos_api::dns::{Blocklist, BlocklistProvider};
let providers = vec![
BlocklistProvider {
zone: "zen.spamhaus.org".into(),
enabled: true,
refusal_codes: vec!["127.255.255.0/24".into()],
refusal_cooldown_secs: 120,
},
BlocklistProvider {
zone: "dbl.spamhaus.org".into(),
enabled: false,
..Default::default()
},
];
let server = serve(200, "");
client(&server)
.set_blocklist_config(Blocklist::Rbl, true, &providers, 3600)
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/rbl");
let body = seen.json();
assert_eq!(body["enabled"], true);
assert_eq!(body["refusal_cooldown_secs"], 3600);
let sent = body["providers"].as_array().expect("providers is a list");
assert_eq!(sent.len(), 2, "both providers, since this replaces the whole list");
assert_eq!(sent[0]["zone"], "zen.spamhaus.org");
assert_eq!(sent[0]["refusal_codes"][0], "127.255.255.0/24");
assert_eq!(sent[0]["refusal_cooldown_secs"], 120);
assert_eq!(sent[1]["enabled"], false);
assert!(sent[1].get("refusal_codes").is_none());
assert!(sent[1].get("refusal_cooldown_secs").is_none());
}
#[tokio::test]
async fn rotated_out_providers_are_read_back() {
use townos_api::dns::Blocklist;
let server = serve(
200,
r#"{"enabled":true,"providers":[{"zone":"zen.spamhaus.org","enabled":true}],"refusal_cooldown_secs":3600,"rotated_out":[{"zone":"zen.spamhaus.org","code":"127.255.255.254","seconds_remaining":1800}]}"#,
);
let config = client(&server).blocklist_config(Blocklist::Rbl).await.unwrap();
let _ = server.seen();
assert_eq!(config.rotated_out.len(), 1);
assert_eq!(config.rotated_out[0].seconds_remaining, 1800);
assert_eq!(config.rotated_out[0].code, "127.255.255.254");
}
#[tokio::test]
async fn local_blocklist_entries_go_to_the_rbl_and_allowlist_to_the_dnsbl() {
let server = serve(200, r#"[{"name":"ads.example","reason":"ads"}]"#);
let entries = client(&server).local_rbl().await.unwrap();
assert_eq!(server.seen().target, "/dns/rbl/local");
assert_eq!(entries[0].name, "ads.example");
let server = serve(200, "");
client(&server).add_local_rbl("ads.example", "ads").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/dns/rbl/local/add");
assert_eq!(seen.json()["name"], "ads.example");
assert_eq!(seen.json()["reason"], "ads");
let server = serve(200, "");
client(&server).remove_local_rbl("ads.example").await.unwrap();
assert_eq!(server.seen().target, "/dns/rbl/local/remove");
let server = serve(200, "[]");
client(&server).dnsbl_allowlist().await.unwrap();
assert_eq!(server.seen().target, "/dns/dnsbl/allowlist");
let server = serve(200, "");
client(&server).add_dnsbl_allowlist("cdn.example", "needed").await.unwrap();
assert_eq!(server.seen().target, "/dns/dnsbl/allowlist/add");
let server = serve(200, "");
client(&server).remove_dnsbl_allowlist("cdn.example").await.unwrap();
assert_eq!(server.seen().target, "/dns/dnsbl/allowlist/remove");
}
#[tokio::test]
async fn a_network_without_a_subnet_is_not_an_overlay() {
let server = serve(
200,
r#"[{"name":"home","tld":"home.town","subnet":"","listen_port":0},
{"name":"office","tld":"office.town","subnet":"10.9.0.0/24","listen_port":51820,"running":true}]"#,
);
let networks = client(&server).networks().await.unwrap();
assert_eq!(server.seen().target, "/networks");
assert!(!networks[0].is_overlay(), "home is a DNS-only scope");
assert!(networks[1].is_overlay());
}
#[tokio::test]
async fn peers_are_scoped_to_a_network_by_query_string() {
let server = serve(200, "[]");
client(&server).peers("office net").await.unwrap();
assert_eq!(server.seen().target, "/networks/peers?network=office%20net");
}
#[tokio::test]
async fn enrolling_sends_the_public_half_and_never_a_private_key() {
let server = serve(
200,
r#"{"peer":{"network":"office","public_key":"pub","allowed_ip":"10.9.0.2/32","expires_at":"2026-08-13T12:00:00Z"},
"config":"[Interface]\nPrivateKey = REPLACE_WITH_YOUR_PRIVATE_KEY\n"}"#,
);
let enrollment = client(&server)
.add_peer("office", "laptop (linux)", Some("pub"), "")
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/networks/peers/add");
let body = seen.json();
assert_eq!(body["network"], "office");
assert_eq!(body["name"], "laptop (linux)");
assert_eq!(body["public_key"], "pub");
assert_eq!(body["endpoint"], "");
assert_eq!(body["rolodex"], false);
assert!(
!seen.body.contains("private"),
"no private key field goes out: {:?}",
seen.body
);
assert!(enrollment.private_key.is_none(), "we supplied the key, so the box sent none");
assert!(enrollment.peer.expires_at.is_some(), "a non-admin enrollment carries a TTL");
}
#[tokio::test]
async fn an_endpoint_is_passed_through_when_the_machine_is_reachable() {
let server = serve(200, r#"{"peer":{"network":"office","public_key":"pub"},"config":""}"#);
client(&server)
.add_peer("office", "branch box", Some("pub"), "branch.example.com:51820")
.await
.unwrap();
assert_eq!(server.seen().json()["endpoint"], "branch.example.com:51820");
}
#[tokio::test]
async fn letting_the_box_generate_the_keypair_sends_an_empty_key() {
let server = serve(
200,
r#"{"peer":{"network":"office","public_key":"pub"},"private_key":"generated","config":""}"#,
);
let enrollment = client(&server).add_peer("office", "device", None, "").await.unwrap();
assert_eq!(server.seen().json()["public_key"], "");
assert_eq!(enrollment.private_key.as_deref(), Some("generated"));
}
#[tokio::test]
async fn a_refresh_reports_the_new_expiry() {
let server = serve(
200,
r#"{"network":"office","public_key":"pub","expires_at":"2026-08-13T14:00:00Z"}"#,
);
let refreshed = client(&server).refresh_peer("office", "pub").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/networks/peers/refresh");
assert_eq!(seen.json()["network"], "office");
assert_eq!(seen.json()["public_key"], "pub");
assert_eq!(refreshed.expires_at.to_rfc3339(), "2026-08-13T14:00:00+00:00");
}
#[tokio::test]
async fn a_permanent_enrollment_is_distinguishable_from_a_reaped_one() {
let server = serve(
200,
r#"[{"network":"office","public_key":"pub","allowed_ip":"10.9.0.2/32","expires_at":null}]"#,
);
let peers = client(&server).peers("office").await.unwrap();
let _ = server.seen();
assert_eq!(peers.len(), 1);
assert!(peers[0].expires_at.is_none(), "null means it never lapses");
}
#[tokio::test]
async fn removing_a_peer_and_toggling_a_network() {
let server = serve(200, "");
client(&server).remove_peer("office", "pub").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/networks/peers/remove");
assert_eq!(seen.json()["public_key"], "pub");
let server = serve(200, "");
client(&server).enable_network("office").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/networks/enable");
assert_eq!(seen.json()["name"], "office");
let server = serve(200, "");
client(&server).disable_network("office").await.unwrap();
assert_eq!(server.seen().target, "/networks/disable");
}
#[tokio::test]
async fn connected_peers_carry_live_kernel_state() {
let server = serve(
200,
r#"[{"network":"office","public_key":"pub","connected":true,"rx_bytes":2048,"tx_bytes":1024,"last_handshake":"2026-08-13T11:59:00Z","endpoint":"203.0.113.4:1234"}]"#,
);
let peers = client(&server).connected_peers().await.unwrap();
assert_eq!(server.seen().target, "/networks/peers/connected");
assert!(peers[0].connected);
assert_eq!(peers[0].rx_bytes, 2048);
assert!(peers[0].last_handshake.is_some());
assert_eq!(peers[0].endpoint.as_deref(), Some("203.0.113.4:1234"));
}
#[tokio::test]
async fn no_object_storage_is_an_empty_list_not_an_error() {
let server = serve(200, "[]");
let partitions = client(&server).partitions().await.unwrap();
assert_eq!(server.seen().target, "/gfeh");
assert!(partitions.is_empty());
}
#[tokio::test]
async fn a_partitions_published_names_become_urls() {
let server = serve(
200,
r#"[{"network":"home","tld":"home.town","quota":0,"running":true,
"names":[{"view":"s3","fqdn":"s3.gfeh.home.town","port":443,"http":false},
{"view":"http","fqdn":"files.home.town","port":8080,"http":true}]}]"#,
);
let partitions = client(&server).partitions().await.unwrap();
let _ = server.seen();
assert_eq!(partitions[0].names[0].url(), "https://s3.gfeh.home.town");
assert_eq!(partitions[0].names[1].url(), "http://files.home.town:8080");
}
#[tokio::test]
async fn principals_and_grants_are_scoped_by_query_string() {
let server = serve(200, "[]");
client(&server).principals("home").await.unwrap();
assert_eq!(server.seen().target, "/gfeh/principals?network=home");
let server = serve(200, "[]");
client(&server).grants("home", "alice").await.unwrap();
assert_eq!(server.seen().target, "/gfeh/grants?network=home&principal=alice");
let server = serve(200, "[]");
client(&server).exposures("home").await.unwrap();
assert_eq!(server.seen().target, "/gfeh/exposures?network=home");
}
#[tokio::test]
async fn a_grant_is_reported_as_stored_not_as_asked_for() {
let server = serve(
200,
r#"{"id":7,"principal":"alice","path":"/photos","perm":["read"],"inheritable":true}"#,
);
let asked = vec!["read".to_string(), "write".to_string(), "delete".to_string()];
let stored = client(&server)
.add_grant("home", "alice", "/photos", &asked, true)
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/gfeh/grants/add");
let body = seen.json();
assert_eq!(body["principal"], "alice");
assert_eq!(body["path"], "/photos");
assert_eq!(body["inheritable"], true);
assert_eq!(body["perm"].as_array().unwrap().len(), 3, "all three were asked for");
assert_eq!(stored.perm, vec!["read".to_string()], "one was stored");
assert_eq!(stored.id, 7);
}
#[tokio::test]
async fn principals_grants_and_exposures_are_changed_by_post() {
let server = serve(200, r#"{"name":"alice","ceiling":["read","write"],"account":true}"#);
let principal = client(&server).add_principal("home", "alice").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/gfeh/principals/add");
assert_eq!(seen.json()["principal"], "alice");
assert!(principal.account);
let server = serve(200, "");
client(&server).remove_principal("home", "alice").await.unwrap();
assert_eq!(server.seen().target, "/gfeh/principals/remove");
let server = serve(200, "");
client(&server).revoke_grant("home", 7).await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/gfeh/grants/revoke");
assert_eq!(seen.json()["id"], 7, "the id is a number, not a string");
let server = serve(200, "");
client(&server).withdraw_exposure("home", "tok").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/gfeh/exposures/withdraw");
assert_eq!(seen.json()["token"], "tok");
}
#[tokio::test]
async fn listing_volumes_is_a_post_with_paging_and_sort() {
let server = serve(
200,
r#"{"entries":[{"name":"user/photos","quota":1073741824,"state":"user"}],"has_more":false,"total_count":1}"#,
);
let page = client(&server)
.filesystems("", Some("user"), 200, 0, "cat")
.await
.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/storage"));
let body = seen.json();
assert_eq!(body["name"], "");
assert_eq!(body["limit"], 200);
assert_eq!(body["offset"], 0);
assert_eq!(body["state"], "user");
assert_eq!(body["search"], "cat");
assert_eq!(body["sort_by"], "name");
assert_eq!(body["sort_order"], "asc");
assert_eq!(page.entries[0].quota, 1024 * 1024 * 1024);
assert!(!page.has_more);
}
#[tokio::test]
async fn an_absent_state_filter_spans_every_state() {
let server = serve(200, r#"{"entries":[]}"#);
client(&server).filesystems("", None, 50, 0, "").await.unwrap();
let body = server.seen().json();
assert!(body.get("state").is_none(), "no filter means no field");
assert!(body.get("search").is_none(), "an empty search is not a search for nothing");
}
#[tokio::test]
async fn modifying_a_volume_sends_the_old_name_beside_the_new_filesystem() {
use townos_api::Filesystem;
let server = serve(200, "");
let fs = Filesystem {
name: "user/pictures".into(),
quota: 2 * 1024 * 1024 * 1024,
state: String::new(),
};
client(&server).modify_filesystem("user/photos", &fs).await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/storage/modify");
let body = seen.json();
assert_eq!(body["name"], "user/photos", "the name identifying the volume");
assert_eq!(body["filesystem"]["name"], "user/pictures", "the name it becomes");
assert_eq!(body["filesystem"]["quota"], 2u64 * 1024 * 1024 * 1024);
assert!(
body["filesystem"].get("state").is_none(),
"state is the box's classification, not something a client sets"
);
}
#[tokio::test]
async fn creating_and_removing_a_volume() {
use townos_api::Filesystem;
let server = serve(200, "");
client(&server)
.create_filesystem(&Filesystem {
name: "scratch".into(),
quota: 0,
state: String::new(),
})
.await
.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/storage/create");
assert_eq!(seen.json()["name"], "scratch");
assert_eq!(seen.json()["quota"], 0, "zero is how unlimited is spelled");
let server = serve(200, "");
client(&server).remove_filesystem("user/scratch").await.unwrap();
let seen = server.seen();
assert_eq!(seen.target, "/storage/remove");
assert_eq!(seen.json()["name"], "user/scratch");
}
#[tokio::test]
async fn an_upload_is_multipart_with_the_file_part_named_archive() {
let dir = std::env::temp_dir().join(format!("townos-wire-up-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let archive = dir.join("backup.tar.gz");
std::fs::write(&archive, b"not really a tarball, but bytes are bytes").unwrap();
let server = serve(200, r#"{"needs_restart":true,"message":"archive unpacked successfully"}"#);
let out = client(&server)
.upload_archive("user/photos", &archive, "incoming", "gitea.service")
.await
.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/storage/upload-archive"));
assert!(
seen.content_type
.as_deref()
.is_some_and(|t| t.starts_with("multipart/form-data; boundary=")),
"content type was {:?}",
seen.content_type
);
for expected in [
r#"name="subvolume""#,
r#"name="subpath""#,
r#"name="stop_service""#,
r#"name="archive""#,
r#"filename="backup.tar.gz""#,
"user/photos",
"incoming",
"gitea.service",
"not really a tarball",
] {
assert!(seen.body.contains(expected), "multipart body is missing {expected}");
}
assert!(out.needs_restart);
assert_eq!(out.message, "archive unpacked successfully");
let _ = std::fs::remove_dir_all(&dir);
}
#[tokio::test]
async fn optional_upload_fields_are_left_out_when_empty() {
let dir = std::env::temp_dir().join(format!("townos-wire-up2-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let archive = dir.join("backup.tar");
std::fs::write(&archive, b"bytes").unwrap();
let server = serve(200, r#"{"needs_restart":true,"message":"ok"}"#);
client(&server)
.upload_archive("user/photos", &archive, "", "")
.await
.unwrap();
let seen = server.seen();
assert!(seen.body.contains(r#"name="subvolume""#));
assert!(!seen.body.contains(r#"name="subpath""#));
assert!(!seen.body.contains(r#"name="stop_service""#));
let _ = std::fs::remove_dir_all(&dir);
}
#[tokio::test]
async fn uploading_a_file_that_is_not_there_is_a_local_io_error() {
let server = serve(200, "{}");
let missing = std::env::temp_dir().join("town-os-no-such-archive.tar.gz");
let _ = std::fs::remove_file(&missing);
let err = client(&server)
.upload_archive("user/photos", &missing, "", "")
.await
.unwrap_err();
assert!(matches!(err, townos_api::Error::Io { .. }), "got {err:?}");
assert_eq!(err.http_status(), None);
assert!(!err.is_unauthenticated(), "this must not sign the user out");
drop(server);
}
#[tokio::test]
async fn a_download_streams_to_the_path_it_was_given() {
let body: Vec<u8> = (0..5000u32).map(|i| (i % 251) as u8).collect();
let server = serve_bytes(200, "application/gzip", body.clone());
let dir = std::env::temp_dir().join(format!("townos-wire-down-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let out = dir.join("photos.tar.gz");
let written = client(&server)
.download_archive("user/photos", &["a".into(), "b".into()], "tar.gz", &out)
.await
.unwrap();
let seen = server.seen();
assert_eq!((seen.method.as_str(), seen.target.as_str()), ("POST", "/storage/download-archive"));
let request = seen.json();
assert_eq!(request["subvolume"], "user/photos");
assert_eq!(request["format"], "tar.gz");
assert_eq!(request["paths"], serde_json::json!(["a", "b"]));
assert_eq!(written, body.len() as u64);
assert_eq!(std::fs::read(&out).unwrap(), body, "every byte landed, in order");
let _ = std::fs::remove_dir_all(&dir);
}
#[tokio::test]
async fn download_defaults_leave_paths_and_format_out() {
let server = serve_bytes(200, "application/gzip", b"archive".to_vec());
let dir = std::env::temp_dir().join(format!("townos-wire-down2-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let out = dir.join("all.tar.gz");
client(&server).download_archive("user/photos", &[], "", &out).await.unwrap();
let request = server.seen().json();
assert_eq!(request["subvolume"], "user/photos");
assert!(request.get("paths").is_none());
assert!(request.get("format").is_none());
let _ = std::fs::remove_dir_all(&dir);
}
#[tokio::test]
async fn a_problem_detail_becomes_the_message_shown() {
let server = serve(
403,
r#"{"type":"about:blank","status":403,"title":"Forbidden","detail":"administrator required"}"#,
);
let err = client(&server).setup_dns().await.unwrap_err();
let _ = server.seen();
assert_eq!(err.detail(), "administrator required");
assert!(err.is_forbidden());
assert!(!err.is_unauthenticated(), "a 403 must not end the session");
}
#[tokio::test]
async fn a_401_is_what_ends_a_session() {
let server = serve(401, r#"{"message":"invalid session"}"#);
let err = client(&server).networks().await.unwrap_err();
let _ = server.seen();
assert!(err.is_unauthenticated());
assert_eq!(err.detail(), "invalid session");
}
#[tokio::test]
async fn a_404_is_visible_to_the_heartbeat() {
let server = serve(404, r#"{"detail":"peer not found"}"#);
let err = client(&server).refresh_peer("office", "pub").await.unwrap_err();
let _ = server.seen();
assert_eq!(err.http_status(), Some(404));
}
#[tokio::test]
async fn a_success_with_the_wrong_shape_is_a_decode_error_naming_the_path() {
let server = serve(200, r#"{"unexpected":"shape"}"#);
let err = client(&server).whoami().await.unwrap_err();
let _ = server.seen();
assert!(matches!(err, townos_api::Error::Decode { .. }), "got {err:?}");
assert!(err.to_string().contains("/account/me"), "{err}");
}
#[tokio::test]
async fn an_html_error_page_still_produces_something_readable() {
let server = serve(502, "<html><body>Bad Gateway</body></html>");
let err = client(&server).networks().await.unwrap_err();
let _ = server.seen();
assert_eq!(err.http_status(), Some(502));
assert!(err.detail().contains("Bad Gateway"), "{}", err.detail());
}
#[tokio::test]
async fn an_unreachable_box_is_a_transport_error_not_a_status() {
let c = Client::new("127.0.0.1:9").unwrap();
let err = c.ping().await.unwrap_err();
assert_eq!(err.http_status(), None);
assert!(!err.is_unauthenticated(), "an unreachable box must not sign the user out");
assert!(!err.detail().is_empty(), "there has to be something to show");
}