use super::account::*;
use super::browse::*;
use super::client::tests::stub;
use super::client::Client;
use super::fmt::*;
use super::squads::*;
use super::*;
use serde_json::json;
fn argv(s: &str) -> Vec<String> {
s.split_whitespace().map(str::to_string).collect()
}
fn parsed(s: &str) -> Parsed {
Parsed::parse(&argv(s)).unwrap()
}
fn cells(d: &Doc) -> Vec<Vec<String>> {
d.table.as_ref().unwrap().rows.clone()
}
fn model_fixture() -> Value {
json!({
"id": "46361c24", "name": "vit-base-patch16-224", "owner_handle": "cadic-jean",
"visibility": "private", "license": "", "created_at": "2026-11-18T14:00:01+00:00",
"latest_version": {
"digest": "f5d7a1769f5632b28d6f9b4d9b50cf0138e967d9999a0d4dc1ab4f4ee98fb39f",
"status": "ready", "size_bytes": 0, "file_count": 0, "source": "hf",
"published_at": "2026-11-18T14:00:01+00:00",
"meta": {"pipeline_tag": "image-classification", "params_b": 0.087, "license": "apache-2.0",
"downloads": 16004145, "likes": 1055, "hf_repo": "google/vit-base-patch16-224",
"architecture": "ViTForImageClassification", "library_name": "transformers",
"tags": ["vision", "imagenet-1k"]}
},
"versions": [{"digest": "f5d7a1769f5632b28d6f9b4d9b50cf0138e967d9999a0d4dc1ab4f4ee98fb39f",
"status": "ready", "size_bytes": 1500000000, "file_count": 3, "source": "hf",
"published_at": "2026-11-18T14:00:01+00:00"}]
})
}
#[test]
fn arguments_split_into_words_options_and_flags() {
let p = parsed("show abc --limit 5 --gains --name x");
assert_eq!(p.pos, vec!["show", "abc"]);
assert_eq!(p.opt("limit"), Some("5"));
assert_eq!(p.opt("name"), Some("x"));
assert!(p.flag("gains"));
assert_eq!(p.limit(50).unwrap(), 5);
assert_eq!(parsed("--all").limit(50).unwrap(), usize::MAX);
assert!(Parsed::parse(&argv("--limit")).is_err());
assert!(parsed("--limit x").limit(1).is_err());
}
#[test]
fn only_the_new_subcommands_of_existing_verbs_are_ours() {
let ours = |s: &str| dispatch_gate(&argv(&format!("zc {s}")));
assert!(ours("model ls") && ours("model") && ours("squad create a") && ours("usage"));
assert!(ours("dataset ls") && ours("dataset show x") && ours("dataset preview x"));
assert!(!ours("dataset get zc://a/b") && !ours("dataset"));
assert!(ours("space ls") && ours("space cancel x"));
assert!(!ours("space worker") && !ours("space"));
assert!(ours("me status") && !ours("me") && !ours("whoami") && !ours("balance"));
assert!(!ours("spaces status") && !ours("jobs") && !ours("atelier status x") && !ours("ls"));
}
fn dispatch_gate(args: &[String]) -> bool {
let verb = args[1].as_str();
let first = args.get(2).map(String::as_str).unwrap_or("");
match verb {
"model" | "models" | "env" | "envs" | "squad" | "squads" | "usage" | "tx"
| "transactions" | "receipt" | "payouts" | "quotas" | "billing" | "templates"
| "template" | "endpoint" | "endpoints" => true,
"dataset" | "datasets" => ["ls", "list", "show", "preview"].contains(&first),
"space" => ["ls", "list", "show", "batches", "cancel", "pause", "resume"].contains(&first),
"me" | "whoami" | "balance" => ["status", "profile"].contains(&first),
_ => false,
}
}
#[test]
fn the_models_table_reads_the_hubs_catalogue_row() {
let d = models_table(&json!([model_fixture()]), "", 50);
let r = &cells(&d)[0];
assert_eq!(r[1], "cadic-jean/vit-base-patch16-224");
assert_eq!(r[2], "image-classification");
assert_eq!(r[3], "87M");
assert_eq!(r[4], "apache-2.0", "falls back to the card's licence");
assert_eq!(r[6], "2026-11-18");
}
#[test]
fn a_model_search_matches_every_word_across_name_task_and_tags() {
let v = json!([model_fixture(), {"id": "2", "name": "whisper", "owner_handle": "o"}]);
assert_eq!(cells(&models_table(&v, "vision imagenet", 50)).len(), 1);
assert_eq!(cells(&models_table(&v, "VIT", 50)).len(), 1);
assert_eq!(cells(&models_table(&v, "vit whisper", 50)).len(), 0);
let capped = models_table(&v, "", 1);
assert!(capped.note.unwrap().contains("1 more"));
}
#[test]
fn a_model_shows_its_facts_versions_and_activity() {
let m = model_fixture();
let d = model_doc(&m);
assert!(d.kv.contains(&("downloads".into(), "16004145".into())));
assert!(d.note.unwrap().contains("1 version(s)"));
let v = versions_table(&m);
assert_eq!(cells(&v)[0][2], "1.5 GB");
let act = json!({"days": 30, "totals": {"views": 3, "downloads": 1, "calls": 0},
"series": [{"date": "2026-11-01", "views": 0, "downloads": 0, "calls": 0},
{"date": "2026-11-02", "views": 3, "downloads": 1, "calls": 0}]});
let a = activity_doc(&act);
assert_eq!(cells(&a), vec![vec!["2026-11-02", "3", "1", "0"]]);
assert!(a.kv.contains(&("views".into(), "3".into())));
}
#[test]
fn datasets_list_with_records_and_a_format_from_the_file_extension() {
let ds = json!([{"id": "77dd", "name": "customers", "owner_handle": "cadic-jean", "visibility": "private",
"format": "", "latest_version": {"size_bytes": 18832, "published_at": "2026-11-15T16:06:19+00:00",
"meta": {"records": 400, "columns": ["f0", "label"]},
"files": [{"path": "customers.csv", "sha256": "29dc2daea5574809ca183d09e651f3308fd8f0c4", "size_bytes": 18832}]}}]);
let t = datasets_table(&ds, "");
assert_eq!(cells(&t)[0][2], "csv");
assert_eq!(cells(&t)[0][3], "400");
assert_eq!(cells(&t)[0][4], "18.8 KB");
assert!(cells(&datasets_table(&ds, "nothing")).is_empty());
let d = dataset_doc(&ds[0]);
assert!(d.kv.contains(&("columns".into(), "f0, label".into())));
assert_eq!(cells(&d)[0][0], "customers.csv");
}
#[test]
fn a_preview_is_a_table_and_an_unsupported_file_says_so() {
let p = json!({"path": "customers.csv", "format": "csv", "columns": ["f0", "label"],
"rows": [["0.09", "a"], ["1.9", "b"]], "truncated": true});
let d = preview_doc(&p);
assert_eq!(d.table.as_ref().unwrap().headers, vec!["f0", "label"]);
assert_eq!(cells(&d).len(), 2);
assert!(d.note.unwrap().contains("first rows"));
let u = preview_doc(
&json!({"path": "a.arrow", "format": "unsupported", "columns": [], "rows": []}),
);
assert!(u.table.is_none());
assert!(u.note.unwrap().contains("cannot preview"));
}
#[test]
fn the_environment_catalogue_counts_online_hosts_and_the_cheapest() {
let v = json!([{"template_id": "jupyter", "name": "Jupyter", "category": "notebook", "gpu_required": false,
"hosts": [{"online": true, "price_per_hour": 900.0}, {"online": false, "price_per_hour": 300.0}]}]);
let r = &cells(&catalog_table(&v))[0];
assert_eq!(r[4], "1/2");
assert_eq!(r[5], "Â¥300/h");
let e = json!([{"id": "e1", "template_name": "Jupyter", "node_name": "n", "status": "running",
"price_per_hour": 1200.0, "charged_total": 340.4, "running_since": "2026-11-19T01:02:03Z"}]);
let r = &cells(&envs_table(&e))[0];
assert_eq!(
(r[3].as_str(), r[4].as_str(), r[5].as_str()),
("running", "Â¥1,200/h", "Â¥340")
);
assert!(env_doc(&e[0])
.kv
.contains(&("stop reason".into(), "-".into())));
}
#[test]
fn spaces_show_progress_and_their_batches() {
let s = json!({"items": [{"id": "d36", "name": "smoke", "status": "done", "visibility": "private",
"counts": {"pending": 0, "claimed": 1, "succeeded": 3, "failed": 1},
"price_per_batch": 7.5, "spent_zkcr": 22.5, "created_at": "2026-10-05T05:42:31Z"}]});
let r = &cells(&spaces_table(&s))[0];
assert_eq!(
(r[3].as_str(), r[4].as_str(), r[5].as_str()),
("3/5", "1", "7.5")
);
let b = json!({"items": [{"id": 1, "status": "succeeded", "attempts": 3, "duration_s": 6.229,
"claimed_by": "irQjZUvhYvNuYsHr5fJgZcwb3Sw2wb5XZQ", "finished_at": "2026-10-05T06:45:47Z", "last_error": null}],
"next_cursor": "100"});
let d = batches_table(&b);
assert_eq!(cells(&d)[0][3], "6.2");
assert!(d.note.unwrap().contains("--cursor 100"));
assert!(space_doc(&s["items"][0])
.kv
.contains(&("per batch".into(), "7.50".into())));
}
#[test]
fn usage_reads_the_stats_top_jobs_and_daily_series() {
let u = usage_doc(
&json!({"credits_this_month": 1234.5, "credits_last_month": 0.0, "compute_hours": 2.5,
"total_jobs": 7, "success_rate": 98.6, "avg_credits_per_job": 176.4}),
);
assert!(u.kv.contains(&("spent this month".into(), "Â¥1,235".into())));
assert!(u.kv.contains(&("jobs".into(), "7".into())));
assert_eq!(top_jobs_table(&json!([{"job_name": "j", "total_credits": 50.0, "runs": 2, "avg_hours": 0.5, "avg_credits": 25.0}])).rows[0][1], "Â¥50");
assert_eq!(
daily_table(&json!({"labels": ["11/1", "11/2"], "data": [10.0, 20.0]})).rows[1],
vec!["11/2", "Â¥20"]
);
}
#[test]
fn the_ledger_pages_and_names_each_row() {
let v = json!({"transactions": [{"id": 9, "job_name": "Qwen/Qwen3-0.6B", "transaction_type": "forge_train",
"credits_amount": -12.5, "status": "completed", "compute_hours": 0.25, "created_at": "2026-11-18T10:00:00Z"}],
"total": 41, "page": 2, "limit": 20, "pages": 3});
let d = tx_table(&v);
assert_eq!(
cells(&d)[0],
vec![
"9",
"2026-11-18 10:00",
"forge_train",
"Qwen/Qwen3-0.6B",
"-12.50",
"completed",
"0.25"
]
);
assert_eq!(d.note.unwrap(), "page 2 of 3, 41 in all");
}
#[test]
fn payouts_and_quotas_read_the_hubs_figures() {
let p = json!({"account_state": "ready", "payouts_enabled": true, "requirements_due": [],
"withdrawable_credits": 1500.0, "pending_credits": 20.0, "min_withdrawal_credits": 500.0,
"currency": "jpy", "history": [{"created_at": "2026-11-01T00:00:00Z", "credits": 1000.0, "status": "paid"}]});
let d = payouts_doc(&p);
assert!(d.kv.contains(&("withdrawable".into(), "1500.00".into())));
assert!(d.kv.contains(&("still needed".into(), "-".into())));
assert_eq!(cells(&d)[0][2], "paid");
let q = quotas_doc(
&json!({"rate_limit_per_period": 100, "rate_limit_per_week": null, "requests_this_period": 4,
"requests_this_week": 9, "requests_this_month": 30, "rate_limit_per_month": 1000}),
);
assert_eq!(q.kv[0].1, "4 of 100");
assert_eq!(q.kv[1].1, "9, no limit");
}
#[test]
fn squads_templates_and_endpoint_options_render() {
let s = json!([{"id": "s1", "slug": "lab", "name": "Lab", "kind": "trusted", "role": "owner",
"members": [{"email": "a@b.c", "role": "Owner", "joined": "2026-11-01"}], "budget_per_month": 50000.0}]);
let r = &cells(&squads_table(&s))[0];
assert_eq!(
(r[1].as_str(), r[5].as_str(), r[6].as_str()),
("lab", "1", "Â¥50,000")
);
assert_eq!(cells(&squad_doc(&s[0]))[0][0], "a@b.c");
assert_eq!(
nodes_doc(&json!({"squad_id": "s1", "nodes": ["pk1", "pk2"]}))
.table
.unwrap()
.rows
.len(),
2
);
let t = json!([{"id": "vllm", "name": "vLLM", "tier": "Official", "gpu_required": true, "min_vram_gb": 24,
"default_price_per_second": 0.0123, "description": "serve"}]);
assert_eq!(cells(&templates_table(&t))[0][4], "24 GB");
let o = json!({"template_id": "vllm", "requires_gpu": true, "min_vram_gb": 24, "cpu": null,
"tiers": [{"gpu_model": "RTX 4090", "vram_gb": 24, "online": 2, "usable": 0, "price_per_hour": 900.0, "reason": "host not open to you"}]});
let d = options_doc(&o);
assert_eq!(
cells(&d)[0],
vec![
"RTX 4090",
"24 GB",
"2",
"0",
"Â¥900/h",
"host not open to you"
]
);
let invites = invites_table(
&json!([{"id": "i1", "role": "Member", "email": null, "uses": 0, "max_uses": 1,
"status": "valid", "expires_at": "2026-11-26T00:00:00Z"}]),
);
assert_eq!(cells(&invites)[0][3], "0/1");
}
#[test]
fn a_new_squad_starts_from_a_policy_the_hub_can_validate() {
let b = create_body(&parsed("lab --name Lab --budget 5000"), None).unwrap();
assert_eq!(b["slug"], "lab");
assert_eq!(b["name"], "Lab");
assert_eq!(b["budget_per_month"], 5000.0);
assert_eq!(b["policy"]["Statement"][0]["Effect"], "Allow");
assert_eq!(create_body(&parsed("lab"), None).unwrap()["name"], "lab");
assert!(create_body(&parsed(""), None).is_err());
assert!(create_body(&parsed("lab --budget lots"), None).is_err());
let custom = json!({"Version": "2026-01-01", "Statement": []});
assert_eq!(
create_body(&parsed("lab"), Some(custom.clone())).unwrap()["policy"],
custom
);
}
#[test]
fn an_invite_carries_only_what_was_asked_for() {
assert_eq!(invite_body(&parsed("")).unwrap(), json!({}));
let b = invite_body(&parsed("--role Admin --email a@b.c --uses 3 --hours 24")).unwrap();
assert_eq!(
(
b["role"].as_str(),
b["email"].as_str(),
b["max_uses"].as_u64(),
b["expires_in_hours"].as_u64()
),
(Some("Admin"), Some("a@b.c"), Some(3), Some(24))
);
assert!(invite_body(&parsed("--uses many")).is_err());
}
#[test]
fn billing_only_names_the_page() {
let (v, d) = billing("topup", "https://stg.hub.zakuro-ai.com").unwrap();
assert_eq!(v["url"], "https://stg.hub.zakuro-ai.com/billing");
assert!(d.note.unwrap().contains("money moves only there"));
let (v, _) = billing("payout", "https://h").unwrap();
assert_eq!(v["url"], "https://h/provide/earnings");
assert!(
billing("withdraw", "https://h").is_ok(),
"withdraw is the payout page"
);
assert!(billing("pay", "https://h").is_err());
}
#[test]
fn a_verb_reads_through_the_hub_and_json_is_the_hubs_own() {
let (base, seen) = stub(vec![
(
"GET",
"/api/models".into(),
200,
serde_json::to_string(&json!([model_fixture()])).unwrap(),
),
(
"GET",
"/api/models/zz/activity?days=7".into(),
200,
r#"{"days":7,"series":[],"totals":{"views":0,"downloads":0,"calls":0}}"#.into(),
),
(
"DELETE",
"/api/envs/e1".into(),
200,
r#"{"status":"stopped"}"#.into(),
),
(
"POST",
"/api/spaces/s1/pause".into(),
200,
r#"{"status":"paused"}"#.into(),
),
]);
let c = Client::new(&base, "zk_k");
let (v, d) = call_with(&c, "model", "search", &parsed("vit")).unwrap();
assert_eq!(v[0]["name"], "vit-base-patch16-224");
assert_eq!(cells(&d).len(), 1);
assert!(call_with(&c, "model", "search", &parsed("")).is_err());
call_with(&c, "model", "activity", &parsed("zz --days 7")).unwrap();
let (_, d) = call_with(&c, "env", "stop", &parsed("e1")).unwrap();
assert!(d.note.unwrap().contains("stopped"));
let (_, d) = call_with(&c, "space", "pause", &parsed("s1")).unwrap();
assert!(d.note.unwrap().contains("paused"));
assert!(seen
.lock()
.unwrap()
.iter()
.all(|(_, _, a)| a.as_deref() == Some("Bearer zk_k")));
}
#[test]
fn a_named_model_is_resolved_by_the_hub_before_it_is_read() {
let (base, seen) = stub(vec![
(
"GET",
"/api/models/resolve?ref=zc%3A%2F%2Fo%2Fn".into(),
200,
r#"{"model_id":"m-1"}"#.into(),
),
(
"GET",
"/api/models/m-1".into(),
200,
serde_json::to_string(&model_fixture()).unwrap(),
),
]);
let c = Client::new(&base, "zk_k");
call_with(&c, "model", "show", &parsed("o/n")).unwrap();
call_with(&c, "model", "show", &parsed("zc://o/n")).unwrap();
assert_eq!(seen.lock().unwrap().len(), 4);
}
#[test]
fn a_route_the_hub_has_not_widened_yet_says_so_instead_of_failing() {
let (base, _) = stub(vec![
(
"GET",
"/api/usage/stats".into(),
401,
r#"{"detail":"Not authenticated"}"#.into(),
),
("GET", "/api/envs/catalog".into(), 200, "[]".into()),
]);
let c = Client::new(&base, "zk_k");
match call_with(&c, "usage", "", &parsed("")) {
Err(Fail::Hub(HubError::NeedsNewerHub(p))) => assert_eq!(p, "/api/usage/stats"),
other => panic!("{other:?}"),
}
}
#[test]
fn squads_resolve_a_slug_and_write_through_their_routes() {
let (base, seen) = stub(vec![
(
"GET",
"/api/squads".into(),
200,
r#"[{"id":"11111111-1111-1111-1111-111111111111","slug":"lab"}]"#.into(),
),
(
"POST",
"/api/squads/11111111-1111-1111-1111-111111111111/nodes".into(),
200,
r#"{"squad_id":"x","nodes":["pk"]}"#.into(),
),
(
"DELETE",
"/api/squads/11111111-1111-1111-1111-111111111111/nodes".into(),
200,
r#"{"squad_id":"x","nodes":[]}"#.into(),
),
(
"POST",
"/api/squad-invites/accept".into(),
200,
r#"{"name":"Lab","role":"Member","joined":true}"#.into(),
),
(
"POST",
"/api/squads/11111111-1111-1111-1111-111111111111/leave".into(),
200,
"{}".into(),
),
]);
let c = Client::new(&base, "zk_k");
let (_, d) = call_with(&c, "squad", "nodes", &parsed("lab add pk")).unwrap();
assert!(d.note.unwrap().contains("1 node"));
call_with(&c, "squad", "nodes", &parsed("lab remove pk")).unwrap();
let (_, d) = call_with(
&c,
"squad",
"accept",
&parsed("https://stg.hub.zakuro-ai.com/squads/join?token=abc123"),
)
.unwrap();
assert!(d.note.unwrap().contains("joined Lab as Member"));
call_with(&c, "squad", "leave", &parsed("lab")).unwrap();
assert!(call_with(&c, "squad", "nodes", &parsed("lab add")).is_err());
let log = seen.lock().unwrap();
assert!(log
.iter()
.any(|(m, u, _)| m == "DELETE" && u.contains(r#"{"node_pubkey":"pk"}"#)));
assert!(log
.iter()
.any(|(m, u, _)| m == "POST" && u.contains(r#"{"token":"abc123"}"#)));
}
#[test]
fn forge_jobs_show_status_stage_and_cost() {
let v = json!([{"id": "4f6b", "status": "queued", "name": null, "model_ref": "ae5f3db4",
"total_zkcr": 1671.38, "created_at": "2026-11-18T13:42:26Z",
"progress": {"stage": "prepare", "total": 5, "completed": ["fetch"]}},
{"id": "9", "status": "delivered", "name": "my run", "progress": {"stage": null, "total": 5}}]);
let d = jobs_table(&v);
assert_eq!(
cells(&d)[0],
vec![
"4f6b",
"queued",
"ae5f3db4",
"prepare (1/5)",
"Â¥1,671",
"2026-11-18 13:42"
]
);
assert_eq!(cells(&d)[1][2], "my run");
assert_eq!(cells(&d)[1][3], "-");
}
#[test]
fn an_archived_squad_is_marked_in_the_list_and_in_show() {
let v = json!([
{"id": "s1", "slug": "old", "name": "Old", "archived": true, "members": [], "budget_per_month": 0.0},
{"id": "s2", "slug": "new", "name": "New", "archived": false, "members": []}
]);
let d = squads_table(&v);
assert_eq!(cells(&d)[0][2], "Old (archived)");
assert_eq!(cells(&d)[1][2], "New");
assert!(squad_doc(&v[0])
.kv
.contains(&("archived".into(), "yes".into())));
assert!(squad_doc(&v[1])
.kv
.contains(&("archived".into(), "no".into())));
}
#[test]
fn nodes_of_an_archived_squad_say_so_instead_of_no_such_squad() {
let id = "11111111-1111-1111-1111-111111111111";
let (base, _) = stub(vec![
(
"GET",
"/api/squads".into(),
200,
format!(r#"[{{"id":"{id}","slug":"old"}}]"#),
),
(
"GET",
format!("/api/squads/{id}"),
200,
format!(r#"{{"id":"{id}","slug":"old","archived":true}}"#),
),
(
"GET",
format!("/api/squads/{id}/nodes"),
404,
r#"{"detail":"No such squad"}"#.into(),
),
(
"POST",
format!("/api/squads/{id}/nodes"),
404,
r#"{"detail":"No such squad"}"#.into(),
),
]);
let c = Client::new(&base, "zk_k");
for args in ["old", "old add pk"] {
match call_with(&c, "squad", "nodes", &parsed(args)) {
Err(Fail::Usage(m)) => {
assert_eq!(m, "squad old is archived; archived squads have no nodes")
}
other => panic!("{other:?}"),
}
}
}
#[test]
fn a_nodes_404_on_a_live_squad_keeps_the_hubs_words() {
let id = "22222222-2222-2222-2222-222222222222";
let (base, _) = stub(vec![
(
"GET",
"/api/squads".into(),
200,
format!(r#"[{{"id":"{id}","slug":"live"}}]"#),
),
(
"GET",
format!("/api/squads/{id}"),
200,
format!(r#"{{"id":"{id}","slug":"live","archived":false}}"#),
),
(
"GET",
format!("/api/squads/{id}/nodes"),
404,
r#"{"detail":"No such squad"}"#.into(),
),
]);
let c = Client::new(&base, "zk_k");
match call_with(&c, "squad", "nodes", &parsed("live")) {
Err(Fail::Hub(HubError::NotFound(m))) => assert_eq!(m, "No such squad"),
other => panic!("{other:?}"),
}
}