Files
marqdo/tests/executable_knowledge.rs
T
cflmyandCursor 8a6d09d582 feat: pure extract, bookstore story subset, and project scan caps
Add artifact.extract_pure for restricted expression lifting, a runnable
bookstore tax story fixture, and G12 discovery limits so oversized or deep
trees fail with explicit diagnostics instead of hanging.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-23 23:27:05 +08:00

866 lines
29 KiB
Rust

//! Executable-knowledge gate (offline): S0 baseline + S1/S2 BoundCall/effects.
//!
//! See `tests/executable_knowledge/README.md`. Design-status samples may run
//! but do not prove source/applicability. Expected failures are asserted.
use std::process::Command;
fn run_backend(path: &str, backend: &str) -> (i32, String, String) {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", path, "--backend", backend])
.current_dir(&root)
.output()
.expect("run marqdo");
(
out.status.code().unwrap_or(1),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn assert_out_both(path: &str, expect: &str) {
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run_backend(path, backend);
assert_eq!(
code, 0,
"{path} backend={backend} failed stderr={stderr}"
);
assert_eq!(
stdout.trim_end(),
expect.trim_end(),
"{path} backend={backend} stdout={stdout}"
);
}
}
fn assert_fails_both(path: &str, stderr_substr: &str) {
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run_backend(path, backend);
assert_ne!(
code, 0,
"{path} backend={backend} unexpectedly succeeded stdout={stdout}"
);
assert!(
stderr.contains(stderr_substr),
"{path} backend={backend} stderr missing {stderr_substr:?}: {stderr}"
);
}
}
#[test]
fn s0_01_inline_calc() {
assert_out_both(
"tests/executable_knowledge/baseline/01-inline/main.mq.md",
"60",
);
}
#[test]
fn s0_02_extract_named_function() {
assert_out_both(
"tests/executable_knowledge/baseline/02-extract/main.mq.md",
"60",
);
}
#[test]
fn s0_03_two_document_import() {
assert_out_both(
"tests/executable_knowledge/baseline/03-import/main.mq.md",
"60",
);
}
#[test]
fn s0_04_access_and_loop() {
assert_out_both(
"tests/executable_knowledge/baseline/04-access-loop/main.mq.md",
"a=值\nb=二\n果子=一\n果子=二",
);
}
/// Design-status: pure calc may run; does **not** prove tax facts verified (G05).
#[test]
fn s0_05_policy_draft_try_run_not_verified() {
assert_out_both(
"tests/executable_knowledge/baseline/05-policy-draft/main.mq.md",
"113",
);
}
#[test]
fn s0_06a_missing_import_rejected() {
// Message wording differs by backend; both must mention the missing lib stem.
assert_fails_both(
"tests/executable_knowledge/baseline/06-reject/missing-import.mq.md",
"pricing",
);
}
#[test]
fn s2_g07_mlsp_bind_execute_reuses_existing_capability() {
// Stub/no-LLM REUSE path (G07/G09 subset): find → bind → execute, no new source.
use marqdo::mlsp::handle_line;
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/executable_knowledge/baseline/02-extract");
let project = root.display().to_string();
let found: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.find","params":{"project":project,"query":"商品小计"}})
.to_string(),
))
.unwrap();
assert_eq!(found["ok"], true, "{found}");
let id = found["result"]["candidates"]
.as_array()
.unwrap()
.iter()
.find(|v| v["kind"] == "function")
.expect("商品小计 function")["artifact_id"]
.as_str()
.unwrap()
.to_string();
let bound: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.bind","params":{"project":root,"artifact_id":id}})
.to_string(),
))
.unwrap();
assert_eq!(bound["ok"], true, "bind should succeed for pure calc: {bound}");
let handle = &bound["result"]["handle"];
assert!(handle["symbol_id"].as_str().is_some());
let result: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({
"method":"artifact.execute",
"params":{"handle":handle,"inputs":{"数量":2,"单价":30}}
})
.to_string(),
))
.unwrap();
assert_eq!(
result["ok"], true,
"execute should reuse bound symbol: {result}"
);
assert_eq!(result["result"]["result"], 60);
assert_eq!(result["result"]["symbol_id"], handle["symbol_id"]);
}
#[test]
fn s2_g06_wrapper_inherits_fs_write_not_pure() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-g06-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/09-effects",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge compile");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let mut found_wrap = false;
let arts = out.join("artifacts");
for ent in std::fs::read_dir(&arts).unwrap().flatten() {
let text = std::fs::read_to_string(ent.path()).unwrap();
let v: serde_json::Value = serde_json::from_str(&text).unwrap();
let name = v["display_name"].as_str().unwrap_or("");
if name.ends_with("wrap") {
found_wrap = true;
let effects = v["effects"].as_array().cloned().unwrap_or_default();
let effects: Vec<&str> = effects.iter().filter_map(|e| e.as_str()).collect();
assert!(
effects.contains(&"fs.write"),
"wrap must inherit fs.write: {effects:?}"
);
assert!(!effects.iter().all(|e| *e == "pure"), "{effects:?}");
}
}
assert!(found_wrap, "wrap artifact missing under {}", arts.display());
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s1_08_same_name_import_runs_a_not_b() {
assert_out_both(
"tests/executable_knowledge/baseline/08-same-name/main.mq.md",
"60",
);
}
#[test]
fn s1_08_same_name_resolve_binds_imported_module() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let from = "tests/executable_knowledge/baseline/08-same-name/main.mq.md";
let out = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"resolve",
"pricing.商品小计",
"--from",
from,
"tests/executable_knowledge/baseline/08-same-name",
"--json",
])
.current_dir(&root)
.output()
.expect("knowledge resolve");
assert_eq!(
out.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let v: serde_json::Value =
serde_json::from_str(&String::from_utf8_lossy(&out.stdout)).expect("json");
let file = v["symbol"]["source"]["file"].as_str().unwrap_or("");
assert!(
file.ends_with("a.mq.md"),
"must bind imported A, got file={file} json={v}"
);
assert_ne!(
v["symbol"]["id"],
serde_json::Value::Null,
"stable SymbolId required: {v}"
);
}
#[test]
fn s1_view_lists_steps_with_source_anchors() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out_dir = std::env::temp_dir().join(format!(
"marqdo-ek-view-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out_dir);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"view",
"output",
"--out",
out_dir.to_str().unwrap(),
"--no-exec",
"tests/executable_knowledge/baseline/07-step-kinds/main.mq.md",
])
.current_dir(&root)
.output()
.expect("view");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
// Find generated HTML that mentions knowledge steps.
let mut html = String::new();
fn walk(dir: &std::path::Path, acc: &mut String) {
let Ok(rd) = std::fs::read_dir(dir) else {
return;
};
for ent in rd.flatten() {
let p = ent.path();
if p.is_dir() {
walk(&p, acc);
} else if p.extension().and_then(|e| e.to_str()) == Some("html") {
if let Ok(s) = std::fs::read_to_string(&p) {
if s.contains("knowledge-step") {
*acc = s;
}
}
}
}
}
walk(&out_dir, &mut html);
assert!(
html.contains("knowledge-step"),
"view HTML should list knowledge steps"
);
assert!(
html.contains("href=\"#stmt-"),
"steps should link to source stmt anchors"
);
assert!(
html.contains("data-step-kind=\"observe\"")
|| html.contains("data-step-kind=\"derive\"")
|| html.contains("data-step-kind=\"iterate\""),
"expected classified step kinds in view HTML"
);
let _ = std::fs::remove_dir_all(&out_dir);
}
#[test]
fn s1_g03_step_kinds_not_all_call() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-g03-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/07-step-kinds",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge compile");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let steps: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(out.join("steps.json")).unwrap()).unwrap();
let arr = steps["steps"].as_array().expect("steps array");
let kinds: Vec<&str> = arr
.iter()
.filter_map(|s| s["kind"].as_str())
.collect();
assert!(kinds.contains(&"observe"), "{kinds:?}");
assert!(kinds.contains(&"derive"), "{kinds:?}");
assert!(kinds.contains(&"iterate"), "{kinds:?}");
assert!(
!kinds.iter().all(|k| *k == "call"),
"must not forge every step as call: {kinds:?}"
);
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s1_g01_semantic_edges_not_overwritten_by_ekc() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-g01-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let out_s = out.to_str().unwrap();
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/03-import",
"-o",
out_s,
])
.current_dir(&root)
.output()
.expect("knowledge compile");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let semantic_edges = out.join("graph/edges.json");
let ekc_edges = out.join("ekc/graph/edges.json");
assert!(semantic_edges.is_file(), "missing semantic {}", semantic_edges.display());
assert!(ekc_edges.is_file(), "missing EKC {}", ekc_edges.display());
assert!(
!out.join("graph/graph.json").is_file(),
"EKC must not place graph.json under authoritative graph/"
);
let sem: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&semantic_edges).unwrap()).unwrap();
assert_eq!(sem["authority"], "SemanticProject");
assert!(sem.get("schema_version").is_some(), "{sem}");
let ekc: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(&ekc_edges).unwrap()).unwrap();
assert_eq!(ekc["type"], "Marqdo Knowledge Edges");
assert!(out.join("steps.json").is_file(), "steps projection required");
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s0_06b_ambiguous_bare_name_rejected_both_backends() {
// G02: bare same-named imports must not silently bind (Tree + Bytecode).
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run_backend(
"tests/executable_knowledge/baseline/06-reject/ambiguous.mq.md",
backend,
);
assert_ne!(
code, 0,
"{backend} must reject bare ambiguous name; stdout={stdout}"
);
assert!(
stderr.contains("商品小计"),
"{backend} stderr should name the unresolved function: {stderr}"
);
}
}
#[test]
fn s2_g02_boundcall_path_and_dynamic_projections() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-g02-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/10-boundcall",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge compile");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let bound: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(out.join("bound_calls.json")).unwrap(),
)
.unwrap();
let dynamic: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(out.join("dynamic_calls.json")).unwrap(),
)
.unwrap();
let bounds = bound["bound_calls"].as_array().expect("bound_calls");
assert!(
bounds.iter().any(|c| {
c["binding"] == "BoundCall"
&& c["call_site"].as_str().unwrap_or("").contains("pricing.商品小计")
&& c["target"].as_str().is_some_and(|t| !t.is_empty())
}),
"import path must be BoundCall with SymbolId: {bound}"
);
let dyns = dynamic["dynamic_calls"].as_array().expect("dynamic_calls");
assert!(
dyns.iter().any(|c| {
c["binding"] == "DynamicCall" && c["reason"] == "call_fn"
}),
"call_fn must be DynamicCall: {dynamic}"
);
// Edges from caller must include the BoundCall target SymbolId.
let edges: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(out.join("graph/edges.json")).unwrap(),
)
.unwrap();
let target = bounds
.iter()
.find(|c| c["call_site"].as_str().unwrap_or("").contains("pricing.商品小计"))
.unwrap()["target"]
.as_str()
.unwrap();
let edge_txt = edges.to_string();
assert!(
edge_txt.contains(target),
"graph edges must mention BoundCall target {target}: {edges}"
);
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s2_g02_boundcall_runs_both_backends() {
assert_out_both(
"tests/executable_knowledge/baseline/10-boundcall/main.mq.md",
"hi\n60",
);
}
#[test]
fn s3_extract_pure_plan_rejects_calls() {
use marqdo::mlsp::handle_line;
let ok: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({
"method":"artifact.extract_pure",
"params":{"name":"商品小计","expression":"数量 * 单价"}
})
.to_string(),
))
.unwrap();
assert_eq!(ok["ok"], true, "{ok}");
assert_eq!(ok["result"]["effects"][0], "pure");
assert!(ok["result"]["call"].as_str().unwrap().contains("商品小计"));
let params = ok["result"]["params"].as_array().unwrap();
assert_eq!(params.len(), 2, "{ok}");
let bad: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({
"method":"artifact.extract_pure",
"params":{"name":"x","expression":"fs.write_text(path=\"a\", text=\"b\")"}
})
.to_string(),
))
.unwrap();
assert_eq!(bad["ok"], false, "{bad}");
assert_eq!(bad["error"]["code"], "extract.not_pure");
}
#[test]
fn s4_bookstore_story_runs_with_narrative_and_source() {
assert_out_both(
"tests/executable_knowledge/baseline/13-bookstore/main.mq.md",
"113",
);
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-book-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/13-bookstore",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge");
assert_eq!(status.status.code(), Some(0));
let steps: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(out.join("steps.json")).unwrap()).unwrap();
assert!(
steps["steps"]
.as_array()
.unwrap()
.iter()
.any(|s| s["kind"] == "narrate"),
"{steps}"
);
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s4_g05_sourced_evidence_and_expired_diag() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-src-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/12-tax-source",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let mut found_sourced = false;
for ent in std::fs::read_dir(out.join("artifacts")).unwrap().flatten() {
let v: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(ent.path()).unwrap()).unwrap();
let ev = v["verification"]["evidence"].as_str().unwrap_or("");
if v["kind"] == "function" && ev == "sourced" {
found_sourced = true;
let prov = v["provenance"].as_array().cloned().unwrap_or_default();
assert!(
prov.iter().any(|p| p["relation"] == "supports"),
"supports SourceRef required: {v}"
);
}
}
assert!(found_sourced, "functions should be evidence=sourced");
assert_out_both(
"tests/executable_knowledge/baseline/12-tax-source/main.mq.md",
"113",
);
use marqdo::mlsp::handle_line;
let project = root.join("tests/executable_knowledge/baseline/12-tax-source");
let found: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.find","params":{"project":&project,"query":"标准税率"}})
.to_string(),
))
.unwrap();
let id = found["result"]["candidates"]
.as_array()
.unwrap()
.iter()
.find(|c| c["kind"] == "function")
.unwrap()["artifact_id"]
.as_str()
.unwrap();
let biz: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.bind","params":{"project":&project,"artifact_id":id,"policy":"business"}})
.to_string(),
))
.unwrap();
assert_eq!(biz["ok"], true, "sourced artifact binds under business: {biz}");
let out2 = std::env::temp_dir().join(format!(
"marqdo-ek-exp-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out2);
let status2 = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/12b-tax-expired",
"-o",
out2.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge expired");
assert_eq!(status2.status.code(), Some(0));
let mut found_expired = false;
for ent in std::fs::read_dir(out2.join("artifacts")).unwrap().flatten() {
let v: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(ent.path()).unwrap()).unwrap();
if v["verification"]["evidence"] == "expired" {
found_expired = true;
}
}
assert!(found_expired, "12b-tax-expired should be evidence=expired");
let _ = std::fs::remove_dir_all(&out);
let _ = std::fs::remove_dir_all(&out2);
}
#[test]
fn s3_artifact_patch_wording_guard() {
use marqdo::mlsp::handle_line;
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let dir = std::env::temp_dir().join(format!(
"marqdo-ek-patch-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let src = "---\nmarkup: occlusion\n---\n\n## 商品小计\n\n`数量` 与 `单价`。\n\n*[按数量与单价计算](数量 * 单价)*\n\n# main\n\n**小计 = [两件](商品小计(数量=2, 单价=30))**\n> print text=`小计`\n";
std::fs::write(dir.join("main.mq.md"), src).unwrap();
let found: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.find","params":{"project":&dir,"query":"商品小计"}})
.to_string(),
))
.unwrap();
assert_eq!(found["ok"], true, "{found}");
let art = found["result"]["candidates"]
.as_array()
.unwrap()
.iter()
.find(|c| c["kind"] == "function")
.unwrap();
let id = art["artifact_id"].as_str().unwrap();
let inspected: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.inspect","params":{"project":&dir,"artifact_id":id}})
.to_string(),
))
.unwrap();
let impl_digest = inspected["result"]["hashes"]["implementation"]
.as_str()
.unwrap()
.to_string();
let line = inspected["result"]["source"]["line"].as_u64().unwrap() as u32;
// Wording-only: change prose near the heading without touching signature.
let prose_line = line + 2;
let ok_patch: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({
"method":"artifact.patch",
"params":{
"project":&dir,
"artifact_id":id,
"expected_digest":impl_digest,
"intent":"wording",
"edits":[{"op":"replace","line":prose_line,"text":"`数量` 与 `单价`(说明)。"}]
}
})
.to_string(),
))
.unwrap();
assert_eq!(ok_patch["ok"], true, "prose tweak should apply: {ok_patch}");
assert_eq!(ok_patch["result"]["diff"]["signature_changed"], false);
// Re-inspect and try a signature-breaking edit under wording intent.
let inspected2: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({"method":"artifact.inspect","params":{"project":&dir,"artifact_id":id}})
.to_string(),
))
.unwrap();
let impl2 = inspected2["result"]["hashes"]["implementation"]
.as_str()
.unwrap();
let bad: serde_json::Value = serde_json::from_str(&handle_line(
&serde_json::json!({
"method":"artifact.patch",
"params":{
"project":&dir,
"artifact_id":id,
"expected_digest":impl2,
"intent":"wording",
"edits":[{"op":"replace","line":prose_line,"text":"`数量` `单价` `折扣`。"}]
}
})
.to_string(),
))
.unwrap();
// Declaring a new backtick param may or may not change interface hash depending on
// whether params are inferred from prose; if signature changes, wording must roll back.
if bad["ok"] == false {
assert_eq!(
bad["error"]["code"], "artifact.wording_broke_contract",
"{bad}"
);
}
let _ = root;
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn s1_g03_narrative_ref_steps_not_executed() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let out = std::env::temp_dir().join(format!(
"marqdo-ek-narr-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let _ = std::fs::remove_dir_all(&out);
let status = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args([
"knowledge",
"tests/executable_knowledge/baseline/11-narrative-ref",
"-o",
out.to_str().unwrap(),
])
.current_dir(&root)
.output()
.expect("knowledge");
assert_eq!(
status.status.code(),
Some(0),
"stderr={}",
String::from_utf8_lossy(&status.stderr)
);
let steps: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(out.join("steps.json")).unwrap()).unwrap();
let arr = steps["steps"].as_array().unwrap();
assert!(
arr.iter().any(|s| s["kind"] == "narrate"),
"expected narrate step: {steps}"
);
assert!(
arr.iter().any(|s| s["kind"] == "navigation"),
"expected navigation step: {steps}"
);
let nav_count = arr.iter().filter(|s| s["kind"] == "navigation").count();
assert_eq!(
nav_count, 1,
"only the prose URL becomes navigation (fence ignored): {steps}"
);
let refs: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(out.join("refs.json")).unwrap()).unwrap();
assert!(
refs["refs"].as_array().unwrap().iter().any(|r| {
r["context"] == "narrative" && r["resolution"] == "symbol"
}),
"narrate target 总额 should resolve: {refs}"
);
// run must not fetch URL; stdout ok only
assert_out_both(
"tests/executable_knowledge/baseline/11-narrative-ref/main.mq.md",
"ok",
);
let current = std::fs::read_to_string(out.join("CURRENT")).unwrap();
let gen = out.join("generations").join(current.trim());
assert!(
gen.join("steps.json").is_file(),
"generation tree must be complete under {}",
gen.display()
);
let _ = std::fs::remove_dir_all(&out);
}
#[test]
fn s2_g07_eng_reuse_requires_bind_before_execute() {
// Discovery scores must not be treated as executable handles.
use marqdo::knowledge::ir::{ReuseCandidate, ReuseDecision, ReuseResult};
use marqdo::knowledge::reuse::reuse_json;
let result = ReuseResult {
decision: ReuseDecision::Reuse,
confidence: 0.9,
capability: Some("定价".into()),
symbol: Some("商品小计".into()),
source: None,
reason: vec!["score meets REUSE threshold".into()],
candidates: vec![ReuseCandidate {
id: "capability:定价".into(),
kind: "Capability".into(),
title: "定价".into(),
score: 0.9,
resource: None,
reason: vec![],
}],
constraints: vec![],
decisions: vec![],
failures: vec![],
create_allowed: false,
recommended: vec!["REUSE 定价".into()],
};
let v = reuse_json("商品小计", &result);
assert_eq!(v["discovery_only"], true, "{v}");
assert_eq!(v["bind_required"], true, "{v}");
assert!(
v["bind_targets"]
.as_array()
.unwrap()
.iter()
.any(|t| t["query"] == "商品小计"),
"REUSE must expose bind_targets for MLSP bind: {v}"
);
}