//! 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, 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::().unwrap())).unwrap_or(0); while data.len()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)->(Value,Vec) { 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(){ 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(){ 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(); }