Establish author baseline fixtures and offline tests, make SemanticProject the sole authority for graph edges, classify named steps, and tighten local reuse so unknown effects are not pure and MLSP binds by SymbolId. Co-authored-by: Cursor <cursoragent@cursor.com>
437 lines
14 KiB
Rust
437 lines
14 KiB
Rust
//! S0 executable-knowledge baseline gate (offline).
|
|
//!
|
|
//! See `tests/executable_knowledge/README.md`. Design-status samples may run
|
|
//! but do not prove source/applicability. Expected failures are asserted;
|
|
//! the bytecode ambiguous-name defect is fingerprinted until S2 BoundCall.
|
|
|
|
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 s0_06b_ambiguous_bare_name_tree_rejects() {
|
|
let (code, stdout, stderr) = run_backend(
|
|
"tests/executable_knowledge/baseline/06-reject/ambiguous.mq.md",
|
|
"tree",
|
|
);
|
|
assert_ne!(code, 0, "tree should reject bare ambiguous name; stdout={stdout}");
|
|
assert!(
|
|
stderr.contains("商品小计"),
|
|
"tree stderr should name the unresolved function: {stderr}"
|
|
);
|
|
}
|
|
|
|
/// Baseline defect fingerprint (S2 BoundCall must flip this to a hard failure).
|
|
///
|
|
/// Today bytecode silently picks one of the same-named imports (`60` from A or
|
|
/// `120` from B — order is not stable). When fixed, change this test to
|
|
/// `assert_ne!(code, 0)` on both backends.
|
|
#[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_bytecode_ambiguous_wrongly_resolves_baseline_defect() {
|
|
let (code, stdout, stderr) = run_backend(
|
|
"tests/executable_knowledge/baseline/06-reject/ambiguous.mq.md",
|
|
"bytecode",
|
|
);
|
|
assert_eq!(
|
|
code, 0,
|
|
"baseline defect: bytecode still wrongly resolves; if this fails with \
|
|
a rejection, BoundCall may have landed — flip test to expect failure. stderr={stderr}"
|
|
);
|
|
let out = stdout.trim_end();
|
|
assert!(
|
|
out == "60" || out == "120",
|
|
"baseline defect fingerprint: silent pick of A(60) or B(120), got {out:?}"
|
|
);
|
|
}
|