312 lines
11 KiB
Rust
312 lines
11 KiB
Rust
use std::process::Command;
|
|
|
|
#[test]
|
|
fn report_to_routinator_csv_exports_sorted_rows() {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let report = dir.path().join("report.json");
|
|
let out_csv = dir.path().join("vrps.csv");
|
|
std::fs::write(
|
|
&report,
|
|
r#"{
|
|
"format_version": 2,
|
|
"meta": {"validation_time_rfc3339_utc": "2026-03-13T02:30:00Z"},
|
|
"policy": {},
|
|
"tree": {"instances_processed": 0, "instances_failed": 0, "warnings": []},
|
|
"publication_points": [],
|
|
"vrps": [
|
|
{"asn": 64497, "prefix": "203.0.113.0/24", "max_length": 24},
|
|
{"asn": 64496, "prefix": "192.0.2.0/24", "max_length": 24}
|
|
],
|
|
"aspas": [],
|
|
"downloads": [],
|
|
"download_stats": {"events_total": 0, "by_kind": {}}
|
|
}"#,
|
|
)
|
|
.expect("write report");
|
|
|
|
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("scripts/payload_replay/report_to_routinator_csv.py");
|
|
let out = Command::new("python3")
|
|
.arg(&script)
|
|
.args([
|
|
"--report",
|
|
report.to_string_lossy().as_ref(),
|
|
"--out",
|
|
out_csv.to_string_lossy().as_ref(),
|
|
"--trust-anchor",
|
|
"apnic",
|
|
])
|
|
.output()
|
|
.expect("run export script");
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"script failed: status={}\nstdout={}\nstderr={}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stdout),
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let csv = std::fs::read_to_string(&out_csv).expect("read csv");
|
|
let lines: Vec<_> = csv.lines().collect();
|
|
assert_eq!(lines[0], "ASN,IP Prefix,Max Length,Trust Anchor");
|
|
assert_eq!(lines[1], "AS64496,192.0.2.0/24,24,apnic");
|
|
assert_eq!(lines[2], "AS64497,203.0.113.0/24,24,apnic");
|
|
}
|
|
|
|
#[test]
|
|
fn compare_with_routinator_record_reports_diff_counts() {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let ours = dir.path().join("ours.csv");
|
|
let record = dir.path().join("record.csv");
|
|
let summary = dir.path().join("summary.md");
|
|
let only_ours = dir.path().join("only_ours.csv");
|
|
let only_record = dir.path().join("only_record.csv");
|
|
|
|
std::fs::write(
|
|
&ours,
|
|
"ASN,IP Prefix,Max Length,Trust Anchor\nAS64496,192.0.2.0/24,24,apnic\nAS64497,198.51.100.0/24,24,apnic\n",
|
|
)
|
|
.expect("write ours csv");
|
|
std::fs::write(
|
|
&record,
|
|
"ASN,IP Prefix,Max Length,Trust Anchor\nAS64496,192.0.2.0/24,24,apnic\nAS64498,203.0.113.0/24,24,apnic\n",
|
|
)
|
|
.expect("write record csv");
|
|
|
|
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("scripts/payload_replay/compare_with_routinator_record.sh");
|
|
let out = Command::new(&script)
|
|
.args([
|
|
ours.to_string_lossy().as_ref(),
|
|
record.to_string_lossy().as_ref(),
|
|
summary.to_string_lossy().as_ref(),
|
|
only_ours.to_string_lossy().as_ref(),
|
|
only_record.to_string_lossy().as_ref(),
|
|
])
|
|
.output()
|
|
.expect("run compare script");
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"script failed: status={}\nstdout={}\nstderr={}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stdout),
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let summary_text = std::fs::read_to_string(&summary).expect("read summary");
|
|
assert!(
|
|
summary_text.contains("| ours_total | 2 |"),
|
|
"{summary_text}"
|
|
);
|
|
assert!(
|
|
summary_text.contains("| record_total | 2 |"),
|
|
"{summary_text}"
|
|
);
|
|
assert!(
|
|
summary_text.contains("| intersection | 1 |"),
|
|
"{summary_text}"
|
|
);
|
|
assert!(
|
|
summary_text.contains("| only_in_ours | 1 |"),
|
|
"{summary_text}"
|
|
);
|
|
assert!(
|
|
summary_text.contains("| only_in_record | 1 |"),
|
|
"{summary_text}"
|
|
);
|
|
|
|
let only_ours_text = std::fs::read_to_string(&only_ours).expect("read only ours csv");
|
|
assert!(only_ours_text.contains("AS64497,198.51.100.0/24,24,apnic"));
|
|
let only_record_text = std::fs::read_to_string(&only_record).expect("read only record csv");
|
|
assert!(only_record_text.contains("AS64498,203.0.113.0/24,24,apnic"));
|
|
}
|
|
|
|
#[test]
|
|
fn write_multi_rir_case_report_combines_compare_and_timing() {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let snapshot_meta = dir.path().join("snapshot_meta.json");
|
|
let delta_meta = dir.path().join("delta_meta.json");
|
|
let snapshot_compare = dir.path().join("snapshot_compare.md");
|
|
let delta_compare = dir.path().join("delta_compare.md");
|
|
let out_md = dir.path().join("case_report.md");
|
|
let out_json = dir.path().join("case_report.json");
|
|
|
|
std::fs::write(
|
|
&snapshot_meta,
|
|
r#"{
|
|
"durations_secs": {"rpki_run": 12},
|
|
"counts": {"vrps": 10, "aspas": 1}
|
|
}"#,
|
|
)
|
|
.expect("write snapshot meta");
|
|
std::fs::write(
|
|
&delta_meta,
|
|
r#"{
|
|
"durations_secs": {"rpki_run": 8},
|
|
"counts": {"vrps": 11, "aspas": 1}
|
|
}"#,
|
|
)
|
|
.expect("write delta meta");
|
|
std::fs::write(
|
|
&snapshot_compare,
|
|
"# compare\n\n| metric | value |\n|---|---:|\n| ours_total | 10 |\n| record_total | 10 |\n| intersection | 10 |\n| only_in_ours | 0 |\n| only_in_record | 0 |\n",
|
|
)
|
|
.expect("write snapshot compare");
|
|
std::fs::write(
|
|
&delta_compare,
|
|
"# compare\n\n| metric | value |\n|---|---:|\n| ours_total | 11 |\n| record_total | 11 |\n| intersection | 11 |\n| only_in_ours | 0 |\n| only_in_record | 0 |\n",
|
|
)
|
|
.expect("write delta compare");
|
|
|
|
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("scripts/payload_replay/write_multi_rir_case_report.py");
|
|
let out = Command::new("python3")
|
|
.arg(&script)
|
|
.args([
|
|
"--rir",
|
|
"afrinic",
|
|
"--snapshot-meta",
|
|
snapshot_meta.to_string_lossy().as_ref(),
|
|
"--snapshot-compare",
|
|
snapshot_compare.to_string_lossy().as_ref(),
|
|
"--delta-meta",
|
|
delta_meta.to_string_lossy().as_ref(),
|
|
"--delta-compare",
|
|
delta_compare.to_string_lossy().as_ref(),
|
|
"--routinator-base-seconds",
|
|
"6.0",
|
|
"--routinator-delta-seconds",
|
|
"4.0",
|
|
"--out-md",
|
|
out_md.to_string_lossy().as_ref(),
|
|
"--out-json",
|
|
out_json.to_string_lossy().as_ref(),
|
|
])
|
|
.output()
|
|
.expect("run case report script");
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"script failed: status={}\nstdout={}\nstderr={}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stdout),
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let report: serde_json::Value =
|
|
serde_json::from_slice(&std::fs::read(&out_json).expect("read report json"))
|
|
.expect("parse report json");
|
|
assert_eq!(report["rir"].as_str(), Some("afrinic"));
|
|
assert_eq!(report["snapshot"]["match"].as_bool(), Some(true));
|
|
assert_eq!(report["delta"]["match"].as_bool(), Some(true));
|
|
assert_eq!(report["snapshot"]["ratio"].as_f64(), Some(2.0));
|
|
assert_eq!(report["delta"]["ratio"].as_f64(), Some(2.0));
|
|
|
|
let md = std::fs::read_to_string(&out_md).expect("read markdown");
|
|
assert!(md.contains("AFRINIC Replay Report"), "{md}");
|
|
assert!(md.contains("| snapshot | true | 12.000 | 6.000 | 2.000 | 0 | 0 |"), "{md}");
|
|
assert!(md.contains("| delta | true | 8.000 | 4.000 | 2.000 | 0 | 0 |"), "{md}");
|
|
}
|
|
|
|
#[test]
|
|
fn write_multi_rir_summary_aggregates_case_reports() {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let case_root = dir.path().join("cases");
|
|
for (rir, snapshot_ratio, delta_ratio) in [
|
|
("afrinic", 2.0_f64, 3.0_f64),
|
|
("apnic", 1.5_f64, 2.5_f64),
|
|
("arin", 1.1_f64, 1.6_f64),
|
|
("lacnic", 3.8_f64, 4.8_f64),
|
|
("ripe", 2.7_f64, 2.6_f64),
|
|
] {
|
|
let rir_dir = case_root.join(rir);
|
|
std::fs::create_dir_all(&rir_dir).expect("create rir dir");
|
|
let report = serde_json::json!({
|
|
"rir": rir,
|
|
"snapshot": {
|
|
"match": true,
|
|
"ours_seconds": 10.0,
|
|
"routinator_seconds": 5.0,
|
|
"ratio": snapshot_ratio,
|
|
"compare": {"only_in_ours": 0, "only_in_record": 0}
|
|
},
|
|
"delta": {
|
|
"match": true,
|
|
"ours_seconds": 12.0,
|
|
"routinator_seconds": 6.0,
|
|
"ratio": delta_ratio,
|
|
"compare": {"only_in_ours": 0, "only_in_record": 0}
|
|
}
|
|
});
|
|
std::fs::write(
|
|
rir_dir.join(format!("{rir}_case_report.json")),
|
|
serde_json::to_vec_pretty(&report).expect("serialize report"),
|
|
)
|
|
.expect("write report");
|
|
}
|
|
|
|
let out_md = dir.path().join("summary.md");
|
|
let out_json = dir.path().join("summary.json");
|
|
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("scripts/payload_replay/write_multi_rir_summary.py");
|
|
let out = Command::new("python3")
|
|
.arg(&script)
|
|
.args([
|
|
"--case-root",
|
|
case_root.to_string_lossy().as_ref(),
|
|
"--out-md",
|
|
out_md.to_string_lossy().as_ref(),
|
|
"--out-json",
|
|
out_json.to_string_lossy().as_ref(),
|
|
])
|
|
.output()
|
|
.expect("run summary script");
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"script failed: status={}\nstdout={}\nstderr={}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stdout),
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let json: serde_json::Value =
|
|
serde_json::from_slice(&std::fs::read(&out_json).expect("read summary json"))
|
|
.expect("parse summary json");
|
|
assert_eq!(json["cases"].as_array().map(|v| v.len()), Some(5));
|
|
assert_eq!(json["summary"]["snapshot_all_match"].as_bool(), Some(true));
|
|
assert_eq!(json["summary"]["delta_all_match"].as_bool(), Some(true));
|
|
assert!(json["summary"]["all_ratio_geomean"].as_f64().unwrap_or(0.0) > 0.0);
|
|
|
|
let md = std::fs::read_to_string(&out_md).expect("read summary md");
|
|
assert!(md.contains("Multi-RIR Replay Summary"), "{md}");
|
|
assert!(md.contains("| afrinic | true | 10.000 | 5.000 | 2.000 | true | 12.000 | 6.000 | 3.000 |"), "{md}");
|
|
}
|
|
|
|
#[test]
|
|
fn apnic_snapshot_profile_script_dry_run_builds_command() {
|
|
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("scripts/payload_replay/run_apnic_snapshot_replay_profile.sh");
|
|
let out = Command::new("bash")
|
|
.env("DRY_RUN", "1")
|
|
.arg(&script)
|
|
.output()
|
|
.expect("run profile script dry-run");
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"script failed: status={}\nstdout={}\nstderr={}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stdout),
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let stdout = String::from_utf8_lossy(&out.stdout);
|
|
assert!(stdout.contains("--payload-replay-archive"), "{stdout}");
|
|
assert!(stdout.contains("--payload-replay-locks"), "{stdout}");
|
|
assert!(stdout.contains("--analyze"), "{stdout}");
|
|
assert!(stdout.contains("--profile-cpu"), "{stdout}");
|
|
}
|