Files
marqdo/tests/release_handbook.rs

357 lines
22 KiB
Rust

//! Isolated publication ordering and package-role checks through the real handbooks.
use std::{fs,io::{Read,Write},net::{TcpListener,TcpStream},path::PathBuf,process::{Command,Stdio},
sync::{Arc,atomic::{AtomicBool,Ordering}},thread,time::{Duration,Instant}};
use serde_json::{json,Value};
fn root()->PathBuf { PathBuf::from(env!("CARGO_MANIFEST_DIR")) }
fn native()->Command { let mut cmd=Command::new(env!("CARGO_BIN_EXE_marqdo"));cmd.current_dir(root());cmd }
fn invoke(file:&str,function:&str,args:Value,effects:&str,work:&std::path::Path,env:&[(String,String)])->Value {
let mut cmd=native();
cmd.args(["call",file,function,"--args-json","-","--effects",effects,"--fs-root",work.to_str().unwrap(),"--json"]);
for (k,v) in env {cmd.env(k,v);}
let mut child=cmd.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
child.stdin.take().unwrap().write_all(args.to_string().as_bytes()).unwrap();
let out=child.wait_with_output().unwrap();
assert!(out.status.success(),"{}",String::from_utf8_lossy(&out.stdout));
let answer:Value=serde_json::from_slice(&out.stdout).unwrap();
assert_eq!(answer["ok"],true,"{answer}");answer["result"].clone()
}
fn engineering()->PathBuf {
let name=if cfg!(target_os="windows"){"engineering.dll"}else if cfg!(target_os="macos"){"libengineering.dylib"}else{"libengineering.so"};
let lib=root().join("target/debug").join(name);
if !lib.is_file() {
let result=invoke("lib/sys.mq.md","exec",json!({"cmd":"cargo","args":["build","-p","marqdo_plugin_engineering","--offline"],"capture":true}),"process.exec",&root(),&[]);
assert_eq!(result["code"],0,"{result}");
}
assert!(lib.is_file());lib
}
#[derive(Debug)]
struct Request { path:String, body:Vec<u8>, headers:String }
fn request(mut stream:TcpStream)->Request {
stream.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
let mut data=Vec::new();let mut chunk=[0u8;4096];
let header_end=loop {
let n=stream.read(&mut chunk).unwrap();assert!(n>0);data.extend_from_slice(&chunk[..n]);
assert!(data.len()<65536);
if let Some(i)=data.windows(4).position(|v|v==b"\r\n\r\n"){break i+4;}
};
let headers=String::from_utf8(data[..header_end].to_vec()).unwrap();
let length=headers.lines().find_map(|line|line.split_once(':').filter(|(k,_)|k.eq_ignore_ascii_case("content-length"))
.map(|(_,v)|v.trim().parse::<usize>().unwrap())).unwrap_or(0);
while data.len()<header_end+length {
let n=stream.read(&mut chunk).unwrap();assert!(n>0);data.extend_from_slice(&chunk[..n]);
}
let path=headers.lines().next().unwrap().split_whitespace().nth(1).unwrap().to_string();
Request{path,body:data[header_end..header_end+length].to_vec(),headers}
}
fn upload(fail_at:Option<usize>)->(Value,Vec<Request>) {
let work=std::env::temp_dir().join(format!("mq-r2-order-{}-{}",std::process::id(),fail_at.unwrap_or(0)));
fs::create_dir_all(&work).unwrap();
let lib=engineering();
let listener=TcpListener::bind("127.0.0.1:0").unwrap();listener.set_nonblocking(true).unwrap();
let address=listener.local_addr().unwrap();
let done=Arc::new(AtomicBool::new(false));let server_done=done.clone();
let server=thread::spawn(move||{
let started=Instant::now();let mut events=Vec::new();
while started.elapsed()<Duration::from_secs(30) {
match listener.accept() {
Ok((mut stream,_))=>{
let event=request(stream.try_clone().unwrap());
events.push(event);
let status=if fail_at==Some(events.len()){"503 Service Unavailable"}else{"200 OK"};
stream.write_all(format!("HTTP/1.1 {status}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").as_bytes()).unwrap();
},
Err(e) if e.kind()==std::io::ErrorKind::WouldBlock=>{
if server_done.load(Ordering::SeqCst){break;}
thread::sleep(Duration::from_millis(5));
},
Err(e)=>panic!("{e}"),
}
}
events
});
let names=["marqdo-9.8.7-ext.zip","marqdo-9.8.7-native-x86_64-pc-windows-msvc.zip","marqdo-9.8.7-native-x86_64-unknown-linux-gnu.zip"];
let mut files=Vec::new();
for name in names {
fs::write(work.join(name),b"isolated transport fixture\n").unwrap();
let digest=invoke("lib/fs.mq.md","file_hash",json!({"path":name}),"fs.read",&work,&[]);
files.push(json!({"name":name,"path":name,"sha256":digest}));
}
let env=vec![
("MARQDO_ENGINEERING_PLUGIN".into(),lib.display().to_string()),
("MARQDO_RELEASE_CREDENTIAL_HOME".into(),work.display().to_string()),
("R2_ENDPOINT".into(),format!("http://{address}")),
("R2_BUCKET".into(),"fixture".into()),
("R2_REGION".into(),"auto".into()),
("R2_ACCESS_KEY_ID".into(),"fixture-key".into()),
("R2_SECRET_ACCESS_KEY".into(),"fixture-secret-never-real".into()),
];
let result=invoke("skills/marqdo-release/asset_io.mq.md","upload",json!({"version":"9.8.7","files":files}),"plugin",&work,&env);
done.store(true,Ordering::SeqCst);
let events=server.join().unwrap();
assert!(!result.to_string().contains("fixture-secret"));
fs::remove_dir_all(work).unwrap();
(result,events)
}
#[test]
fn all_six_packs_are_written_before_either_version_pointer() {
let (result,events)=upload(None);assert_eq!(result["ok"],true,"{result}");
assert_eq!(events.len(),8,"{events:?}");
for request in &events[..6] {
assert!(request.path.ends_with(".zip"));assert_eq!(request.body,b"isolated transport fixture\n");
assert!(request.headers.contains("AWS4-HMAC-SHA256"));
assert!(!request.headers.contains("fixture-secret"));
}
assert_eq!(events[6].path,"/fixture/v9.8.7/VERSION");
assert_eq!(events[7].path,"/fixture/latest/VERSION");
assert_eq!(events[6].body,b"9.8.7\n");assert_eq!(events[7].body,b"9.8.7\n");
}
#[test]
fn failed_pack_upload_stops_before_publication_pointers() {
let (result,events)=upload(Some(4));assert_eq!(result["ok"],false,"{result}");
assert_eq!(events.len(),4,"{events:?}");
assert!(events.iter().all(|r|!r.path.ends_with("/VERSION")));
}
#[test]
fn source_role_checks_package_version_and_declared_native_capability() {
let bad=invoke("skills/marqdo-release/assets.mq.md","content",json!({
"version":"9.8.7","record":{"name":"marqdo-9.8.7-source.zip","entries":["Cargo.toml"],
"metadata":{"Cargo.toml":"[package]\nname=\"fixture\"\nversion = \"1.0.0\"\n[dependencies.fake]\nversion = \"9.8.7\"\n"}}
}),"none",&root(),&[]);
assert_eq!(bad["ok"],false);assert_eq!(bad["error"]["code"],"release.source_version");
let bad=invoke("skills/marqdo-release/assets.mq.md","matrix",json!({"records":[
{"name":"marqdo-9.8.7-ext.zip","entries":["ext/engineering/index.mq.md"]},
{"name":"marqdo-9.8.7-native-x86_64-pc-windows-msvc.zip","entries":[]},
{"name":"marqdo-9.8.7-native-x86_64-unknown-linux-gnu.zip","entries":["native/libengineering.so"]}
]}),"none",&root(),&[]);
assert_eq!(bad["ok"],false);assert_eq!(bad["error"]["code"],"release.native_capability");
}
#[test]
fn source_audit_keeps_failed_evidence_and_does_not_execute_documents() {
let work=std::env::temp_dir().join(format!("mq-handbook-audit-{}",std::process::id()));
fs::create_dir_all(&work).unwrap();
fs::write(work.join("content.mq.md"),"# Read this page\n\nThis heading contains explanatory prose only.\n").unwrap();
fs::write(work.join("uncontracted.mq.md"),"---\nmarkup: occlusion\n---\n\n## task\n\nAfter choosing this fixed result we return *42*.\n").unwrap();
fs::write(work.join("broken.mq.md"),"---\nmarkup: occlusion\n---\n\n## task\n\nWe **x = [Broken expression](1 +)**.\n").unwrap();
let env=vec![("MARQDO_ENGINEERING_PLUGIN".into(),engineering().display().to_string())];
let report=invoke("skills/marqdo-dev/files.mq.md","audit",json!({"paths":["content.mq.md","uncontracted.mq.md","broken.mq.md"]}),"plugin,fs.read",&work,&env);
assert_eq!(report["ok"],false,"{report}");
assert_eq!(report["error"]["code"],"authoring.incomplete");
let records=report["value"]["reports"].as_array().unwrap();
assert_eq!(records.len(),3);
assert_eq!(records[0]["ok"],true,"{records:?}");
assert_eq!(records[1]["missing_contracts"][0]["name"],"task");
assert_eq!(records[2]["ok"],false);
assert!(!records[2]["diagnostics"].as_array().unwrap().is_empty());
fs::remove_dir_all(work).unwrap();
}
#[test]
fn release_commit_preflight_preserves_wrong_branch_directory_and_unrelated_index() {
let work=std::env::temp_dir().join(format!("mq-commit-scope-{}",std::process::id()));
fs::create_dir_all(work.join("nested")).unwrap();
let git=|args:&[&str]|{
let out=Command::new("git").current_dir(&work).args(args).output().unwrap();
assert!(out.status.success(),"{}",String::from_utf8_lossy(&out.stderr));out.stdout
};
git(&["init","-b","main"]);
git(&["config","user.name","Isolated handbook fixture"]);
git(&["config","user.email","fixture@example.invalid"]);
git(&["config","commit.gpgSign","false"]);
fs::write(work.join("base.txt"),"base\n").unwrap();
git(&["add","base.txt"]);git(&["commit","-m","prepare fixture"]);
fs::write(work.join("reviewed.txt"),"reviewed\n").unwrap();
fs::write(work.join("other.txt"),"unrelated\n").unwrap();
fs::write(work.join("nested/leaf.txt"),"leaf\n").unwrap();
let env=vec![("MARQDO_ENGINEERING_PLUGIN".into(),engineering().display().to_string())];
let args=|paths:Vec<&str>|json!({"paths":paths,"message":"must remain a preflight"});
git(&["checkout","-b","topic"]);
let result=invoke("skills/marqdo-release/local.mq.md","commit",args(vec!["reviewed.txt"]),"plugin,fs.read",&work,&env);
assert_eq!(result["error"]["code"],"release.commit_branch","{result}");
assert!(git(&["diff","--cached","--name-only"]).is_empty());
git(&["checkout","main"]);
let result=invoke("skills/marqdo-release/local.mq.md","commit",args(vec!["nested"]),"plugin,fs.read",&work,&env);
assert_eq!(result["error"]["code"],"release.commit_paths","{result}");
assert!(git(&["diff","--cached","--name-only"]).is_empty());
git(&["add","other.txt"]);let index=git(&["diff","--cached","--name-only"]);
let result=invoke("skills/marqdo-release/local.mq.md","commit",args(vec!["reviewed.txt"]),"plugin,fs.read",&work,&env);
assert_eq!(result["error"]["code"],"release.staged_unrelated","{result}");
assert_eq!(git(&["diff","--cached","--name-only"]),index);
assert_eq!(String::from_utf8(git(&["log","-1","--format=%s"])).unwrap().trim(),"prepare fixture");
git(&["restore","--staged","other.txt"]);
fs::remove_file(work.join("base.txt")).unwrap();
git(&["add","--","base.txt"]);
let committed=invoke("skills/marqdo-release/local.mq.md","commit",
json!({"paths":["base.txt","reviewed.txt"],"message":"retry preserves staged removal"}),
"plugin,fs.read",&work,&env);
assert_eq!(committed["ok"],true,"{committed}");
assert_eq!(String::from_utf8(git(&["log","-1","--format=%s"])).unwrap().trim(),"retry preserves staged removal");
assert!(git(&["ls-files","base.txt"]).is_empty());
assert_eq!(String::from_utf8(git(&["ls-files","reviewed.txt"])).unwrap().trim(),"reviewed.txt");
assert!(!git(&["status","--porcelain","other.txt"]).is_empty());
fs::remove_dir_all(work).unwrap();
}
#[test]
fn packaging_metadata_and_vendor_preparation_use_the_native_handbook() {
let work=std::env::temp_dir().join(format!("mq-package-native-{}",std::process::id()));
fs::create_dir_all(work.join("debian")).unwrap();
fs::create_dir_all(work.join("vendor/fixture/src")).unwrap();
fs::write(work.join("Cargo.toml"),"[package]\nname=\"fixture\"\nversion=\"9.8.7\"\n[dependencies.other]\nversion=\"1.0.0\"\n").unwrap();
fs::write(work.join("debian/changelog"),"marqdo (8.0.0-2ppa4~jammy) jammy; urgency=medium\n\nKeep the reviewed history.\n").unwrap();
let package="skills/marqdo-release/package.mq.md";
assert_eq!(invoke(package,"upstream",json!({}),"fs.read",&work,&[]),"9.8.7");
assert_eq!(invoke(package,"debian_version",json!({"series":"noble"}),"fs.read",&work,&[]),"9.8.7-2ppa4~noble");
let invalid=invoke(package,"debian_version",json!({"series":"noble;invalid"}),"fs.read",&work,&[]);
assert_eq!(invalid["ok"],false);
assert_eq!(invoke(package,"vendor_config",json!({}),"fs.write",&work,&[])["ok"],true);
assert_eq!(fs::read_to_string(work.join(".cargo/config.toml")).unwrap(),"[source.crates-io]\nreplace-with = \"vendored-sources\"\n\n[source.vendored-sources]\ndirectory = \"vendor\"\n");
fs::write(work.join("vendor/fixture/Cargo.toml.orig"),"generated backup").unwrap();
fs::write(work.join("vendor/fixture/src/lib.rs"),"retained source").unwrap();
fs::write(work.join("vendor/fixture/.cargo-checksum.json"),json!({"package":"retained-package-hash","files":{"Cargo.toml.orig":"backup-hash","src/lib.rs":"retained-file-hash"}}).to_string()).unwrap();
let cleaned=invoke(package,"sanitize_vendor",json!({}),"fs.write",&work,&[]);
assert_eq!(cleaned["ok"],true,"{cleaned}");
assert_eq!(cleaned["value"]["removed"],1);assert_eq!(cleaned["value"]["changed"],1);
let checksum:Value=serde_json::from_slice(&fs::read(work.join("vendor/fixture/.cargo-checksum.json")).unwrap()).unwrap();
assert_eq!(checksum["package"],"retained-package-hash");
assert_eq!(checksum["files"]["src/lib.rs"],"retained-file-hash");
assert!(checksum["files"].get("Cargo.toml.orig").is_none());
assert!(!work.join("vendor/fixture/Cargo.toml.orig").exists());
assert_eq!(fs::read_to_string(work.join("vendor/fixture/src/lib.rs")).unwrap(),"retained source");
fs::remove_dir_all(work).unwrap();
}
#[test]
fn independent_pack_build_preserves_sources_requires_all_libraries_and_never_overwrites() {
let work=std::env::temp_dir().join(format!("mq-independent-packs-{}",std::process::id()));
fs::create_dir_all(work.join("ext/example")).unwrap();
fs::create_dir_all(work.join("ext/native")).unwrap();
fs::create_dir_all(work.join("compiled")).unwrap();
fs::write(work.join("ext/VERSION"),"9.8.7\n").unwrap();
fs::write(work.join("ext/example/index.mq.md"),"Readable source retained byte-for-byte.\n").unwrap();
fs::write(work.join("ext/native/unrelated.so"),"do not include in sources").unwrap();
let env=vec![("MARQDO_ENGINEERING_PLUGIN".into(),engineering().display().to_string())];
let args=json!({"version":"9.8.7","platform":"x86_64-unknown-linux-gnu","directory":"out","native_dir":"compiled"});
let invoke_pack=||invoke("skills/marqdo-release/packs.mq.md","build",args.clone(),"plugin,fs.write",&work,&env);
let missing=invoke_pack();
assert_eq!(missing["error"]["code"],"packs.library","{missing}");
assert!(!work.join("out").exists());
for name in ["libweb.so","libagent.so","libquantum.so","liblinalg.so","libllm.so","libengineering.so"] {
fs::write(work.join("compiled").join(name),format!("format-only fixture: {name}\n")).unwrap();
}
let built=invoke_pack();
assert_eq!(built["ok"],true,"{built}");
let value=&built["value"];
let sources=&value["source"];
assert!(sources["archive"]["entries"].as_array().unwrap().contains(&json!("ext/example/index.mq.md")));
assert!(!sources["archive"]["entries"].as_array().unwrap().iter().any(|v|v.as_str().unwrap().contains("unrelated.so")));
assert_eq!(sources["archive"]["metadata"]["ext/VERSION"],"9.8.7\n");
let native_path=work.join(value["native"]["path"].as_str().unwrap());
let native_before=fs::read(&native_path).unwrap();
let mut archive=zip::ZipArchive::new(std::io::Cursor::new(&native_before)).unwrap();
let mut selected=String::new();
archive.by_name("native/libengineering.so").unwrap().read_to_string(&mut selected).unwrap();
assert_eq!(selected,"format-only fixture: libengineering.so\n");
assert_eq!(invoke_pack()["error"]["code"],"packs.output_exists");
assert_eq!(fs::read(native_path).unwrap(),native_before);
assert!(!fs::read_dir(&work).unwrap().any(|e|e.unwrap().file_name().to_string_lossy().starts_with(".release-pack")));
assert_eq!(fs::read_to_string(work.join("ext/example/index.mq.md")).unwrap(),"Readable source retained byte-for-byte.\n");
fs::remove_dir_all(work).unwrap();
}
#[test]
fn independent_release_creation_checks_exact_tag_and_preserves_existing_publication() {
let work=std::env::temp_dir().join(format!("mq-ext-create-{}",std::process::id()));
fs::create_dir_all(&work).unwrap();
let notes="本次变更 / Changes\nOnly isolated fixture data; no live publication.\n";
fs::write(work.join("notes.md"),notes).unwrap();
let listener=TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address=listener.local_addr().unwrap();
let done=Arc::new(AtomicBool::new(false));let server_done=done.clone();
let sha="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
let server=thread::spawn(move||{
let mut events=Vec::new();let mut created=false;let started=Instant::now();
while started.elapsed()<Duration::from_secs(30) {
match listener.accept() {
Ok((mut stream,_))=>{
let event=request(stream.try_clone().unwrap());
let (status,body)=if event.path.ends_with("/git/ref/tags/ext-v9.8.7") {
("200 OK",json!({"object":{"type":"commit","sha":sha}}))
} else if event.headers.starts_with("POST ") && event.path=="/repos/cflmy/marqdo/releases" {
created=true;
("201 Created",json!({"id":77,"tag_name":"ext-v9.8.7","assets":[]}))
} else if event.path.ends_with("/releases/tags/ext-v9.8.7") {
if created {("200 OK",json!({"id":77,"tag_name":"ext-v9.8.7","assets":[]}))}
else {("404 Not Found",json!({"message":"not found"}))}
} else {panic!("unexpected fixture request: {event:?}")};
events.push(event);
let body=body.to_string();
write!(stream,"HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",body.len()).unwrap();
}
Err(e) if e.kind()==std::io::ErrorKind::WouldBlock=>{
if server_done.load(Ordering::SeqCst){break}
thread::sleep(Duration::from_millis(5));
}
Err(e)=>panic!("{e}"),
}
}
events
});
let env=vec![
("MARQDO_ENGINEERING_PLUGIN".into(),engineering().display().to_string()),
("MARQDO_RELEASE_API_BASE".into(),format!("http://{address}")),
("GH_TOKEN".into(),"isolated-fixture-token".into()),
];
let file="skills/marqdo-release/github.mq.md";
let wrong=invoke(file,"create_ext",json!({"version":"9.8.7","path":"notes.md","sha":"different","root":work}),"plugin,fs.read",&work,&env);
assert_eq!(wrong["error"]["code"],"release.source_mismatch","{wrong}");
let args=json!({"version":"9.8.7","path":"notes.md","sha":sha,"root":work});
let first=invoke(file,"create_ext",args.clone(),"plugin,fs.read",&work,&env);
assert_eq!(first["ok"],true,"{first}");assert_eq!(first["value"]["id"],77);
let again=invoke(file,"create_ext",args,"plugin,fs.read",&work,&env);
assert_eq!(again["ok"],true,"{again}");assert_eq!(again["value"]["id"],77);
done.store(true,Ordering::SeqCst);
let events=server.join().unwrap();
let posts:Vec<_>=events.iter().filter(|e|e.headers.starts_with("POST ")).collect();
assert_eq!(posts.len(),1,"{events:?}");
let body:Value=serde_json::from_slice(&posts[0].body).unwrap();
assert_eq!(body["tag_name"],"ext-v9.8.7");
assert_eq!(body["target_commitish"],sha);
assert_eq!(body["body"],notes);
assert_eq!(body["draft"],false);
assert!(events.iter().all(|e|!e.headers.starts_with("PATCH ") && !e.headers.starts_with("DELETE ")));
fs::remove_dir_all(work).unwrap();
}
#[test]
fn extension_ci_rejects_receipt_path_and_byte_drift_before_remote_mutation() {
let work=std::env::temp_dir().join(format!("mq-ext-receipt-{}",std::process::id()));
fs::create_dir_all(work.join(".marqdo/release")).unwrap();
fs::create_dir_all(work.join("dist/ext-release")).unwrap();
let source="dist/ext-release/marqdo-9.8.7-ext.zip";
let native_file="dist/ext-release/marqdo-9.8.7-native-x86_64-unknown-linux-gnu.zip";
for path in [source,native_file] {fs::write(work.join(path),"reviewed fixture bytes").unwrap();}
let source_sha=invoke("lib/fs.mq.md","file_hash",json!({"path":source}),"fs.read",&work,&[]);
let native_sha=invoke("lib/fs.mq.md","file_hash",json!({"path":native_file}),"fs.read",&work,&[]);
let mut receipt=json!({"version":"9.8.7","platform":"x86_64-unknown-linux-gnu",
"source":{"path":source,"sha256":source_sha},"native":{"path":native_file,"sha256":native_sha}});
let save=|value:&Value|fs::write(work.join(".marqdo/release/packs.json"),value.to_string()).unwrap();
save(&receipt);
let env=vec![
("MARQDO_ENGINEERING_PLUGIN".into(),engineering().display().to_string()),
("GITHUB_REF_NAME".into(),"ext-v9.8.7".into()),
("RUNNER_OS".into(),"Linux".into()),
("GITHUB_SHA".into(),"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".into()),
("MARQDO_RELEASE_API_BASE".into(),"http://127.0.0.1:1".into()),
("GH_TOKEN".into(),"isolated-fixture-token".into()),
];
fs::write(work.join(native_file),"changed after verification").unwrap();
let changed=invoke("skills/marqdo-release/packs.mq.md","attach_ci",json!({}),"plugin,fs.read,environment.read",&work,&env);
assert_eq!(changed["error"]["code"],"packs.changed","{changed}");
receipt["source"]["path"]=json!("another-candidate.zip");save(&receipt);
let foreign=invoke("skills/marqdo-release/packs.mq.md","attach_ci",json!({}),"plugin,fs.read,environment.read",&work,&env);
assert_eq!(foreign["error"]["code"],"packs.receipt_path","{foreign}");
fs::remove_dir_all(work).unwrap();
}