Follow-up cleanup of text left by the concurrent implementation: - marqdo-markdown AST, marqdo-ir statements/branch arms, frontend units, payload and signature module docs now describe RFC-LANG-0002 roles (payload carriers, heading modes, if/else groups, while/end, params) - marqdo-expression public docs list parse_payload_statement and stop describing a Markdown-link call that no longer exists - retired markdown.invalid_construct/markdown.inert_executable constants are documented as decode-only history for old Analysis/Trace JSON - drop the stale 'expected red' comment in the CLI integration test - the dev-only .mq.md review aid no longer reports semicolons inside string literals, and skips AST baselines / expected-invalid negatives Verified: fmt, clippy -D warnings and cargo test --workspace --locked green.
1140 lines
41 KiB
Rust
1140 lines
41 KiB
Rust
//! CLI integration tests.
|
|
//!
|
|
//! These tests drive the real `marqdo` binary (`CARGO_BIN_EXE_marqdo`) with
|
|
//! [`std::process::Command`] in throw-away temporary directories. They cover
|
|
//! the public contract from `spec`/blueprint section 13: `init`, `check`,
|
|
//! `run`, `call`, `inspect`, `fmt`, multi-module imports and cycles, lock/sync
|
|
//! reproducibility, plugin inspection and plugin invocation.
|
|
//!
|
|
//! Temporary directories live under the OS temp directory and are removed on
|
|
//! drop; the repository itself is never modified.
|
|
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Command, Output};
|
|
|
|
use sha2::Digest;
|
|
|
|
fn repo_root() -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.parent()
|
|
.expect("crates/cli has a parent")
|
|
.parent()
|
|
.expect("crates has a parent")
|
|
.to_path_buf()
|
|
}
|
|
|
|
/// Remove a directory tree on drop.
|
|
struct TempDir {
|
|
path: PathBuf,
|
|
}
|
|
|
|
impl TempDir {
|
|
fn new(tag: &str) -> Self {
|
|
let nanos = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map(|duration| duration.as_nanos())
|
|
.unwrap_or(0);
|
|
let path = std::env::temp_dir().join(format!(
|
|
"marqdo-cli-integration-{tag}-{}-{nanos}",
|
|
std::process::id()
|
|
));
|
|
fs::create_dir_all(&path)
|
|
.unwrap_or_else(|error| panic!("cannot create {}: {error}", path.display()));
|
|
Self { path }
|
|
}
|
|
|
|
fn path(&self) -> &Path {
|
|
&self.path
|
|
}
|
|
|
|
fn write(&self, relative: &str, contents: &str) {
|
|
let path = self.path.join(relative);
|
|
if let Some(parent) = path.parent() {
|
|
fs::create_dir_all(parent)
|
|
.unwrap_or_else(|error| panic!("cannot create {}: {error}", parent.display()));
|
|
}
|
|
fs::write(&path, contents)
|
|
.unwrap_or_else(|error| panic!("cannot write {}: {error}", path.display()));
|
|
}
|
|
|
|
fn read(&self, relative: &str) -> String {
|
|
fs::read_to_string(self.path.join(relative))
|
|
.unwrap_or_else(|error| panic!("cannot read `{relative}`: {error}"))
|
|
}
|
|
}
|
|
|
|
impl Drop for TempDir {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.path);
|
|
}
|
|
}
|
|
|
|
/// Run the CLI in `dir`.
|
|
fn cli(dir: &Path, args: &[&str]) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
|
.args(args)
|
|
.current_dir(dir)
|
|
.output()
|
|
.unwrap_or_else(|error| panic!("cannot run marqdo {args:?}: {error}"))
|
|
}
|
|
|
|
fn stdout_text(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stdout).to_string()
|
|
}
|
|
|
|
fn stderr_text(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stderr).to_string()
|
|
}
|
|
|
|
fn exit_code(output: &Output) -> i32 {
|
|
output
|
|
.status
|
|
.code()
|
|
.unwrap_or_else(|| panic!("marqdo terminated by a signal: {:?}", output.status))
|
|
}
|
|
|
|
fn assert_exit(output: &Output, expected: i32, context: &str) {
|
|
assert_eq!(
|
|
exit_code(output),
|
|
expected,
|
|
"{context}\n stdout: {}\n stderr: {}",
|
|
stdout_text(output),
|
|
stderr_text(output)
|
|
);
|
|
}
|
|
|
|
fn json_stdout(output: &Output) -> serde_json::Value {
|
|
let text = stdout_text(output);
|
|
serde_json::from_str(&text).unwrap_or_else(|error| {
|
|
panic!("stdout is not a single JSON document: {error}\nstdout: {text}")
|
|
})
|
|
}
|
|
|
|
fn python_available() -> bool {
|
|
Command::new("python3")
|
|
.arg("--version")
|
|
.output()
|
|
.map(|output| output.status.success())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
fn cc_available() -> bool {
|
|
Command::new("cc")
|
|
.arg("--version")
|
|
.output()
|
|
.map(|output| output.status.success())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
#[test]
|
|
fn init_creates_a_runnable_project() {
|
|
let dir = TempDir::new("init");
|
|
let output = cli(dir.path(), &["init", "proj"]);
|
|
assert_exit(&output, 0, "init must succeed");
|
|
assert!(stdout_text(&output).contains("Initialized Marqdo project"));
|
|
let project = dir.path().join("proj");
|
|
assert!(project.join("marqdo.yaml").is_file(), "manifest missing");
|
|
assert!(
|
|
project.join("index.mq.md").is_file(),
|
|
"entry document missing"
|
|
);
|
|
|
|
let check = cli(&project, &["check", "index.mq.md"]);
|
|
assert_exit(&check, 0, "generated project must check cleanly");
|
|
assert!(stdout_text(&check).contains("checked 1 module(s): ok"));
|
|
assert!(stderr_text(&check).is_empty());
|
|
|
|
let run = cli(&project, &["run", "index.mq.md"]);
|
|
assert_exit(&run, 0, "generated project must run");
|
|
assert_eq!(stdout_text(&run), "你好,Marqdo\n");
|
|
|
|
let json = cli(&project, &["check", "index.mq.md", "--json"]);
|
|
assert_exit(&json, 0, "check --json must succeed");
|
|
let value = json_stdout(&json);
|
|
assert_eq!(value["command"], "check");
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["errors"], 0);
|
|
assert!(value["diagnostics"].as_array().is_some());
|
|
assert!(
|
|
stderr_text(&json).is_empty(),
|
|
"--json must not mix stderr text"
|
|
);
|
|
|
|
// `init` refuses to overwrite an existing project.
|
|
let again = cli(dir.path(), &["init", "proj"]);
|
|
assert_exit(&again, 1, "init must refuse an existing manifest");
|
|
assert!(stderr_text(&again).contains("already contains"));
|
|
}
|
|
|
|
#[test]
|
|
fn check_exit_codes_and_diagnostics() {
|
|
let dir = TempDir::new("check");
|
|
dir.write("good.mq.md", "## @exec main\n\n`return 1 + 1`\n");
|
|
dir.write("bad.mq.md", "## @exec f\n\n**a *b* c**\n");
|
|
dir.write(
|
|
"warning.mq.md",
|
|
"**x = 1**\n\n## @exec main\n\n`return 1`\n",
|
|
);
|
|
|
|
let good = cli(dir.path(), &["check", "good.mq.md"]);
|
|
assert_exit(&good, 0, "clean document");
|
|
assert!(stdout_text(&good).contains("checked 1 module(s): ok"));
|
|
|
|
let bad = cli(dir.path(), &["check", "bad.mq.md"]);
|
|
assert_exit(&bad, 1, "invalid executable shape is a hard error");
|
|
let bad_stderr = stderr_text(&bad);
|
|
assert!(bad_stderr.contains("error[sem.payload_nested]"));
|
|
assert!(bad_stderr.contains("check failed"));
|
|
assert!(stdout_text(&bad).is_empty());
|
|
|
|
let bad_json = cli(dir.path(), &["check", "bad.mq.md", "--json"]);
|
|
assert_exit(&bad_json, 1, "check --json keeps the exit code");
|
|
let value = json_stdout(&bad_json);
|
|
assert_eq!(value["command"], "check");
|
|
assert_eq!(value["success"], false);
|
|
assert_eq!(value["errors"], 1);
|
|
let diagnostics = value["diagnostics"].as_array().expect("diagnostics array");
|
|
let nested = diagnostics
|
|
.iter()
|
|
.find(|diagnostic| diagnostic["code"] == "sem.payload_nested")
|
|
.expect("sem.payload_nested diagnostic");
|
|
assert_eq!(nested["severity"], "error");
|
|
assert_eq!(nested["line"], 3);
|
|
assert!(
|
|
diagnostics
|
|
.iter()
|
|
.all(|diagnostic| diagnostic["severity"] == "error"
|
|
|| diagnostic["code"] == "sem.inferred_signature"),
|
|
"the fixture may carry the inferred-signature warning but no other diagnostic"
|
|
);
|
|
assert!(stderr_text(&bad_json).is_empty());
|
|
|
|
// RFC-LANG-0002: a Strong at the Knowledge root is inert prose, not an
|
|
// executable shape, and the old `markdown.inert_executable` warning no
|
|
// longer exists.
|
|
let inert = cli(dir.path(), &["check", "warning.mq.md"]);
|
|
assert_exit(&inert, 0, "inert Knowledge prose does not fail check");
|
|
assert!(stdout_text(&inert).contains("checked 1 module(s): ok"));
|
|
assert!(!stderr_text(&inert).contains("warning["));
|
|
let inert_json = cli(dir.path(), &["check", "warning.mq.md", "--json"]);
|
|
let value = json_stdout(&inert_json);
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(
|
|
value["diagnostics"].as_array().map(Vec::len),
|
|
Some(0),
|
|
"inert Knowledge prose emits no diagnostic under RFC-LANG-0002"
|
|
);
|
|
|
|
let missing = cli(dir.path(), &["check", "missing.mq.md"]);
|
|
assert_exit(&missing, 2, "missing file is a usage/IO error");
|
|
assert!(stderr_text(&missing).contains("error"));
|
|
}
|
|
|
|
#[test]
|
|
fn run_json_embeds_program_stdout() {
|
|
let dir = TempDir::new("run-json");
|
|
dir.write(
|
|
"print.mq.md",
|
|
"## @exec main\n\n`打印(\"你好\")`\n\n`打印(42)`\n\n`return None`\n",
|
|
);
|
|
let output = cli(dir.path(), &["run", "print.mq.md", "--json"]);
|
|
assert_exit(&output, 0, "run --json must succeed");
|
|
// Exactly one JSON document on stdout: program output is embedded, never
|
|
// interleaved with the machine-readable envelope.
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["command"], "run");
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["stdout"], "你好\n42\n");
|
|
assert_eq!(value["value"]["type"], "none");
|
|
assert!(value["trace"].as_array().is_some());
|
|
assert!(stderr_text(&output).is_empty());
|
|
|
|
// Text mode writes program output only to stdout, no JSON envelope.
|
|
let text = cli(dir.path(), &["run", "print.mq.md"]);
|
|
assert_exit(&text, 0, "run must succeed");
|
|
assert_eq!(stdout_text(&text), "你好\n42\n");
|
|
}
|
|
|
|
#[test]
|
|
fn run_refuses_documents_with_compile_errors() {
|
|
let dir = TempDir::new("run-errors");
|
|
dir.write("bad.mq.md", "## @exec f\n\n**a *b* c**\n");
|
|
let output = cli(dir.path(), &["run", "bad.mq.md"]);
|
|
assert_exit(&output, 1, "compile errors must prevent execution");
|
|
let stderr = stderr_text(&output);
|
|
assert!(stderr.contains("sem.payload_nested"));
|
|
assert!(stderr.contains("refusing to run"));
|
|
assert!(stdout_text(&output).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn call_executes_examples_with_typed_arguments() {
|
|
let root = repo_root();
|
|
let examples = root.join("examples");
|
|
let factorial = examples.join("factorial.mq.md");
|
|
|
|
let output = cli(
|
|
&root,
|
|
&[
|
|
"call",
|
|
factorial.to_str().unwrap(),
|
|
"数学.阶乘",
|
|
"--arg",
|
|
"n=5",
|
|
"--json",
|
|
],
|
|
);
|
|
assert_exit(&output, 0, "call must execute factorial");
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["value"]["type"], "int");
|
|
assert_eq!(value["value"]["decimal"], "120");
|
|
|
|
let math = examples.join("math.mq.md");
|
|
let output = cli(
|
|
&root,
|
|
&["call", math.to_str().unwrap(), "计算圆面积", "--json"],
|
|
);
|
|
assert_exit(&output, 0, "call must execute the math example");
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["value"]["type"], "float");
|
|
let area = value["value"]["value"].as_f64().expect("float value");
|
|
assert!(
|
|
(area - std::f64::consts::PI * 16.0).abs() < 1e-12,
|
|
"area={area}"
|
|
);
|
|
|
|
let references = examples.join("references.mq.md");
|
|
let output = cli(
|
|
&root,
|
|
&["call", references.to_str().unwrap(), "计算作用力", "--json"],
|
|
);
|
|
assert_exit(&output, 0, "call must execute the references example");
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["value"]["decimal"], "6");
|
|
|
|
let hello = examples.join("hello.mq.md");
|
|
let output = cli(&root, &["run", hello.to_str().unwrap()]);
|
|
assert_exit(&output, 0, "hello example");
|
|
assert_eq!(stdout_text(&output), "你好,Marqdo\n");
|
|
}
|
|
|
|
#[test]
|
|
fn examples_run_end_to_end_including_foreign_when_available() {
|
|
let root = repo_root();
|
|
let multi = root
|
|
.join("examples")
|
|
.join("multi-module")
|
|
.join("index.mq.md");
|
|
let output = cli(&root, &["run", multi.to_str().unwrap()]);
|
|
assert_exit(&output, 0, "multi-module example");
|
|
let printed = stdout_text(&output);
|
|
let area: f64 = printed.trim().parse().expect("printed float");
|
|
assert!((area - std::f64::consts::PI * 4.0).abs() < 1e-12);
|
|
|
|
if !python_available() {
|
|
println!("skipping python foreign example: python3 is unavailable");
|
|
return;
|
|
}
|
|
let foreign = root.join("examples").join("python-foreign.mq.md");
|
|
let output = cli(
|
|
&root,
|
|
&["run", foreign.to_str().unwrap(), "--allow-foreign"],
|
|
);
|
|
assert_exit(&output, 0, "python foreign example");
|
|
let printed = stdout_text(&output);
|
|
assert!(
|
|
printed.starts_with("28.27"),
|
|
"unexpected foreign output: {printed:?}"
|
|
);
|
|
}
|
|
|
|
fn strict_is_available(root: &Path) -> bool {
|
|
let hello = root.join("examples").join("hello.mq.md");
|
|
let output = cli(
|
|
root,
|
|
&["inspect", hello.to_str().unwrap(), "--platform", "--json"],
|
|
);
|
|
if !output.status.success() {
|
|
return false;
|
|
}
|
|
let value = json_stdout(&output);
|
|
value["platform"]["strict"]["state"] == "available"
|
|
}
|
|
|
|
#[test]
|
|
fn strict_mode_enforces_isolation_or_refuses_closed() {
|
|
let root = repo_root();
|
|
let hello = root.join("examples").join("hello.mq.md");
|
|
let output = cli(&root, &["run", hello.to_str().unwrap(), "--mode", "strict"]);
|
|
if strict_is_available(&root) {
|
|
if output.status.success() {
|
|
assert_eq!(stdout_text(&output), "你好,Marqdo\n");
|
|
// External execution surfaces are rejected at the strict L1 boundary.
|
|
let foreign = cli(
|
|
&root,
|
|
&[
|
|
"run",
|
|
hello.to_str().unwrap(),
|
|
"--mode",
|
|
"strict",
|
|
"--allow-foreign",
|
|
],
|
|
);
|
|
assert_exit(&foreign, 2, "strict must reject foreign grants");
|
|
assert!(stderr_text(&foreign).contains("strict mode currently supports"));
|
|
return;
|
|
}
|
|
|
|
// The snapshot from `inspect --platform` is not a permanent promise:
|
|
// the host can lose namespace capability or resources between the
|
|
// probe and the real launch. GitHub-hosted runners have produced
|
|
// `bwrap: Creating new namespace failed: Resource temporarily
|
|
// unavailable` here. The only acceptable outcome is a fail-closed
|
|
// refusal: non-zero exit, diagnostic, and no project output.
|
|
assert_exit(
|
|
&output,
|
|
1,
|
|
"strict launch failure must fail closed, not fall back",
|
|
);
|
|
let stderr = stderr_text(&output);
|
|
assert!(!stderr.is_empty(), "strict failure had no diagnostic");
|
|
assert!(
|
|
stderr.contains("strict isolation failed")
|
|
|| stderr.contains("refusing to run in strict mode")
|
|
|| stderr.contains("bubblewrap")
|
|
|| stderr.contains("bwrap"),
|
|
"strict failure diagnostic does not identify isolation: {stderr}"
|
|
);
|
|
assert!(
|
|
stderr.contains("namespace")
|
|
|| stderr.contains("Resource temporarily unavailable")
|
|
|| stderr.contains("os error 11"),
|
|
"strict failure diagnostic does not identify the launch failure: {stderr}"
|
|
);
|
|
assert!(
|
|
stdout_text(&output).is_empty(),
|
|
"project output appeared although strict launch failed: {}",
|
|
stdout_text(&output)
|
|
);
|
|
|
|
let json = cli(
|
|
&root,
|
|
&["run", hello.to_str().unwrap(), "--mode", "strict", "--json"],
|
|
);
|
|
if json.status.success() {
|
|
let value = json_stdout(&json);
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["value"]["type"], "none");
|
|
} else {
|
|
assert_exit(
|
|
&json,
|
|
1,
|
|
"strict launch failure keeps exit code 1 in JSON mode",
|
|
);
|
|
let value = json_stdout(&json);
|
|
assert_eq!(value["success"], false);
|
|
assert!(value["error"]
|
|
.as_str()
|
|
.expect("error string")
|
|
.contains("strict"));
|
|
}
|
|
return;
|
|
}
|
|
assert_exit(
|
|
&output,
|
|
1,
|
|
"strict mode must refuse when isolation is absent",
|
|
);
|
|
let stderr = stderr_text(&output);
|
|
assert!(
|
|
stderr.contains("refusing to run in strict mode"),
|
|
"stderr: {stderr}"
|
|
);
|
|
assert!(stderr.contains("isolation"), "stderr: {stderr}");
|
|
assert!(stdout_text(&output).is_empty());
|
|
|
|
let json = cli(
|
|
&root,
|
|
&["run", hello.to_str().unwrap(), "--mode", "strict", "--json"],
|
|
);
|
|
assert_exit(&json, 1, "strict refusal keeps exit code 1 in JSON mode");
|
|
let value = json_stdout(&json);
|
|
assert_eq!(value["success"], false);
|
|
assert!(value["error"]
|
|
.as_str()
|
|
.expect("error string")
|
|
.contains("strict mode"));
|
|
}
|
|
|
|
#[test]
|
|
fn inspect_outputs_ast_units_signatures_ir_and_refs() {
|
|
let root = repo_root();
|
|
let factorial = root.join("examples").join("factorial.mq.md");
|
|
let factorial = factorial.to_str().unwrap();
|
|
|
|
let ast = cli(&root, &["inspect", factorial, "--ast", "--json"]);
|
|
assert_exit(&ast, 0, "inspect --ast");
|
|
let value = json_stdout(&ast);
|
|
assert_eq!(value["command"], "inspect");
|
|
assert_eq!(value["ast"]["kind"], "document");
|
|
|
|
let units = cli(&root, &["inspect", factorial, "--units", "--json"]);
|
|
assert_exit(&units, 0, "inspect --units");
|
|
let value = json_stdout(&units);
|
|
let units = value["units"].as_array().expect("units array");
|
|
assert!(units.iter().any(|unit| unit["kind"] == "function"));
|
|
|
|
let signatures = cli(&root, &["inspect", factorial, "--signature", "--json"]);
|
|
assert_exit(&signatures, 0, "inspect --signature");
|
|
let value = json_stdout(&signatures);
|
|
let signature = value["signatures"]
|
|
.as_array()
|
|
.expect("signatures array")
|
|
.iter()
|
|
.find(|entry| entry["name"] == "数学.阶乘")
|
|
.expect("factorial signature");
|
|
assert_eq!(signature["signature"], "inferred");
|
|
assert_eq!(signature["params"][0]["name"], "n");
|
|
|
|
let ir = cli(&root, &["inspect", factorial, "--ir", "--json"]);
|
|
assert_exit(&ir, 0, "inspect --ir");
|
|
let value = json_stdout(&ir);
|
|
let functions = value["ir"].as_array().expect("IR array");
|
|
assert!(!functions.is_empty());
|
|
assert!(functions[0]["body"].is_array());
|
|
|
|
// A link that resolves cleanly.
|
|
let references = root.join("examples").join("references.mq.md");
|
|
let refs = cli(
|
|
&root,
|
|
&["inspect", references.to_str().unwrap(), "--refs", "--json"],
|
|
);
|
|
assert_exit(&refs, 0, "inspect --refs");
|
|
let value = json_stdout(&refs);
|
|
let edges = value["refs"].as_array().expect("refs array");
|
|
assert!(edges.iter().any(|edge| edge["resolved"] == true));
|
|
|
|
// A broken #anchor is reported as unresolved by `inspect --refs`.
|
|
let dir = TempDir::new("refs");
|
|
dir.write(
|
|
"broken.mq.md",
|
|
"## @exec main\n\n见[断链](#不存在的标题)。\n\n`return 1`\n",
|
|
);
|
|
let broken = cli(dir.path(), &["inspect", "broken.mq.md", "--refs", "--json"]);
|
|
assert_exit(&broken, 0, "inspect --refs never executes the document");
|
|
let value = json_stdout(&broken);
|
|
let edges = value["refs"].as_array().expect("refs array");
|
|
assert_eq!(edges.len(), 1);
|
|
assert_eq!(edges[0]["url"], "#不存在的标题");
|
|
assert_eq!(edges[0]["resolved"], false);
|
|
}
|
|
|
|
#[test]
|
|
fn fmt_normalises_line_endings_and_trailing_newlines() {
|
|
let dir = TempDir::new("fmt");
|
|
dir.write("doc.mq.md", "## @exec main\r\n\r\n`return 1`\r\n\r\n\r\n");
|
|
let before = cli(dir.path(), &["fmt", "--check", "doc.mq.md"]);
|
|
assert_exit(&before, 1, "unformatted document is detected");
|
|
assert!(stderr_text(&before).contains("is not formatted"));
|
|
|
|
let format = cli(dir.path(), &["fmt", "doc.mq.md"]);
|
|
assert_exit(&format, 0, "fmt must rewrite the document");
|
|
let formatted = dir.read("doc.mq.md");
|
|
assert_eq!(formatted, "## @exec main\n\n`return 1`\n");
|
|
assert!(!formatted.contains('\r'));
|
|
|
|
let after = cli(dir.path(), &["fmt", "--check", "doc.mq.md"]);
|
|
assert_exit(&after, 0, "formatted document is accepted");
|
|
}
|
|
|
|
#[test]
|
|
fn multi_module_imports_and_cycles() {
|
|
let dir = TempDir::new("modules");
|
|
dir.write(
|
|
"geometry.mq.md",
|
|
"## @exec 圆面积\n\n`params(r: Number)`\n\n`return math.eval(ref(\"#公式\"), {\"r\": r}, target=\"A\")`\n\n### @knowledge 公式\n\n$$\nA = \\pi r^2\n$$\n",
|
|
);
|
|
dir.write(
|
|
"index.mq.md",
|
|
"---\nimport:\n geometry: \"./geometry.mq.md\"\n---\n\n## @exec main\n\n`面积 = geometry.圆面积(r=2)`\n\n`打印(面积)`\n",
|
|
);
|
|
let run = cli(dir.path(), &["run", "index.mq.md"]);
|
|
assert_exit(&run, 0, "multi-module import must run");
|
|
let printed: f64 = stdout_text(&run).trim().parse().expect("printed float");
|
|
assert!((printed - std::f64::consts::PI * 4.0).abs() < 1e-12);
|
|
let check = cli(dir.path(), &["check", "index.mq.md"]);
|
|
assert_exit(&check, 0, "multi-module import must check");
|
|
|
|
// Import cycle diagnostics.
|
|
let cycle = TempDir::new("cycle");
|
|
cycle.write(
|
|
"a.mq.md",
|
|
"---\nimport:\n b: \"./b.mq.md\"\n---\n\n## @exec main\n\n`return 1`\n",
|
|
);
|
|
cycle.write(
|
|
"b.mq.md",
|
|
"---\nimport:\n a: \"./a.mq.md\"\n---\n\n## @exec f\n\n`return 1`\n",
|
|
);
|
|
let output = cli(cycle.path(), &["check", "a.mq.md"]);
|
|
assert_exit(&output, 1, "import cycle is an error");
|
|
let stderr = stderr_text(&output);
|
|
assert!(stderr.contains("module.cycle"), "stderr: {stderr}");
|
|
assert!(stderr.contains("import cycle"), "stderr: {stderr}");
|
|
|
|
// A missing import target is a module.unresolved error.
|
|
let missing = TempDir::new("missing-import");
|
|
missing.write(
|
|
"index.mq.md",
|
|
"---\nimport:\n gone: \"./gone.mq.md\"\n---\n\n## @exec main\n\n`return 1`\n",
|
|
);
|
|
let output = cli(missing.path(), &["check", "index.mq.md"]);
|
|
assert_exit(&output, 1, "missing import target is an error");
|
|
assert!(stderr_text(&output).contains("module.unresolved"));
|
|
}
|
|
|
|
#[test]
|
|
fn lock_and_sync_locked_detect_dependency_tampering() {
|
|
let dir = TempDir::new("lock");
|
|
dir.write(
|
|
"marqdo.yaml",
|
|
"project:\n name: locktest\n version: 0.1.0\ndependencies:\n dep:\n path: \"./dep\"\n",
|
|
);
|
|
dir.write("index.mq.md", "## @exec main\n\n`return 1`\n");
|
|
dir.write("dep/index.mq.md", "## @exec main\n\n`return 1`\n");
|
|
|
|
let lock = cli(dir.path(), &["lock"]);
|
|
assert_exit(&lock, 0, "lock must succeed");
|
|
assert!(stdout_text(&lock).contains("locked 1 package(s)"));
|
|
let lockfile = dir.read("marqdo.lock");
|
|
assert!(lockfile.contains("name: dep"));
|
|
|
|
let sync = cli(dir.path(), &["sync", "--locked"]);
|
|
assert_exit(&sync, 0, "sync --locked must succeed after lock");
|
|
assert!(stdout_text(&sync).contains("synchronized 1 package(s)"));
|
|
|
|
// Tamper with the dependency contents: `sync --locked` must fail.
|
|
dir.write("dep/index.mq.md", "## @exec main\n\n`return 2`\n");
|
|
let tampered = cli(dir.path(), &["sync", "--locked"]);
|
|
assert_exit(&tampered, 1, "tampered dependency must fail sync --locked");
|
|
assert!(stderr_text(&tampered).contains("lockfile is out of date"));
|
|
|
|
// Re-locking restores a consistent state.
|
|
let relock = cli(dir.path(), &["lock"]);
|
|
assert_exit(&relock, 0, "re-lock after tampering");
|
|
let synced = cli(dir.path(), &["sync", "--locked"]);
|
|
assert_exit(&synced, 0, "sync --locked after re-lock");
|
|
}
|
|
|
|
/// Host target and dynamic-library naming for a real Native ABI fixture.
|
|
///
|
|
/// The manifest is generated from the actual host target instead of reusing
|
|
/// the Linux-only example manifest. This is what makes the integration test a
|
|
/// real test on macOS/Windows rather than an accidental "no matching artifact".
|
|
fn host_triple() -> String {
|
|
marqdo_plugin_abi::artifact::current_target_triple()
|
|
.as_str()
|
|
.to_string()
|
|
}
|
|
|
|
fn dynamic_library_name() -> &'static str {
|
|
if cfg!(target_os = "windows") {
|
|
"solver.dll"
|
|
} else if cfg!(target_os = "macos") {
|
|
"solver.dylib"
|
|
} else {
|
|
"solver.so"
|
|
}
|
|
}
|
|
|
|
fn shared_library_flags() -> &'static [&'static str] {
|
|
if cfg!(target_os = "windows") {
|
|
&["-shared"]
|
|
} else if cfg!(target_os = "macos") {
|
|
&["-dynamiclib", "-fPIC"]
|
|
} else {
|
|
&["-shared", "-fPIC"]
|
|
}
|
|
}
|
|
|
|
/// Build the C demo plugin in a temporary directory and generate a manifest for
|
|
/// this host. The repository (including `examples/plugin-demo/plugin.yaml`) is
|
|
/// never modified, and no prebuilt artifact is reused.
|
|
fn build_plugin_copy(tag: &str) -> Option<(TempDir, PathBuf)> {
|
|
build_plugin_copy_with(tag, &[])
|
|
}
|
|
|
|
/// Like [`build_plugin_copy`], with extra C compiler flags for negative fixtures.
|
|
fn build_plugin_copy_with(tag: &str, extra_flags: &[&str]) -> Option<(TempDir, PathBuf)> {
|
|
if !cc_available() {
|
|
// A real C ABI test needs a C toolchain. Windows MSVC does not provide
|
|
// `cc` in the plain runner PATH, so native ABI on Windows is reported
|
|
// as unsupported rather than counted as a pass.
|
|
if cfg!(windows) {
|
|
println!("skipping native plugin test on Windows: no `cc` toolchain");
|
|
return None;
|
|
}
|
|
panic!("`cc` is required for the native plugin integration test on this platform");
|
|
}
|
|
let dir = TempDir::new(tag);
|
|
let target = dir.path().join("plugin-demo");
|
|
fs::create_dir_all(&target).expect("create plugin copy");
|
|
let source = repo_root().join("examples").join("plugin-demo");
|
|
fs::copy(source.join("solver.c"), target.join("solver.c")).expect("copy plugin source");
|
|
|
|
let artifact = target.join(dynamic_library_name());
|
|
let status = Command::new("cc")
|
|
.args(shared_library_flags())
|
|
.args(extra_flags)
|
|
.arg("-I")
|
|
.arg(repo_root().join("include"))
|
|
.args(["-o", artifact.to_str().expect("utf-8 path")])
|
|
.arg(target.join("solver.c"))
|
|
.status()
|
|
.unwrap_or_else(|error| panic!("cannot run cc: {error}"));
|
|
assert!(status.success(), "building the demo plugin failed");
|
|
|
|
let bytes = fs::read(&artifact).expect("read built plugin");
|
|
let digest = hex::encode(sha2::Sha256::digest(&bytes));
|
|
let manifest = format!(
|
|
"plugin:\n name: demo.solver\n version: 0.1.0\n abi: \"^1.0\"\n kind: native\n exports:\n - name: solver.add\n signature: \"($a: Int, $b: Int) -> Int\"\n requires:\n - math.compute\n artifacts:\n - target: {}\n file: {}\n sha256: \"{}\"\n",
|
|
host_triple(),
|
|
dynamic_library_name(),
|
|
digest
|
|
);
|
|
fs::write(target.join("plugin.yaml"), manifest).expect("write plugin.yaml");
|
|
Some((dir, target))
|
|
}
|
|
|
|
#[test]
|
|
fn plugin_inspect_and_explicit_trusted_invocation() {
|
|
let Some((_dir, plugin_dir)) = build_plugin_copy("plugin") else {
|
|
return;
|
|
};
|
|
// Inspection never loads plugin code and verifies the artifact hash.
|
|
let inspect = cli(
|
|
repo_root().as_path(),
|
|
&["plugin", "inspect", plugin_dir.to_str().unwrap(), "--json"],
|
|
);
|
|
assert_exit(&inspect, 0, "plugin inspect");
|
|
let value = json_stdout(&inspect);
|
|
assert_eq!(value["command"], "plugin.inspect");
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["loaded"], false);
|
|
assert_eq!(value["artifact"]["verified"], true);
|
|
assert_eq!(value["exports"][0]["name"], "solver.add");
|
|
|
|
// Invoking a plugin export from a document requires an explicit trust
|
|
// decision, a permission grant and the plugin load itself.
|
|
let dir = TempDir::new("plugin-run");
|
|
dir.write(
|
|
"doc.mq.md",
|
|
"## @exec main\n\n`结果 = solver.add(a=20, b=22)`\n\n`打印(结果)`\n",
|
|
);
|
|
let plugin_path = plugin_dir.to_str().unwrap();
|
|
let doc = dir.path().join("doc.mq.md");
|
|
let doc = doc.to_str().unwrap();
|
|
|
|
let output = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
doc,
|
|
"--plugin",
|
|
plugin_path,
|
|
"--trust-native-plugin",
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
],
|
|
);
|
|
assert_exit(&output, 0, "trusted plugin invocation");
|
|
assert_eq!(stdout_text(&output), "42\n");
|
|
|
|
let untrusted = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
doc,
|
|
"--plugin",
|
|
plugin_path,
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
],
|
|
);
|
|
assert_exit(&untrusted, 1, "in-process loading needs explicit trust");
|
|
assert!(stderr_text(&untrusted).contains("--trust-native-plugin"));
|
|
|
|
let ungranted = cli(
|
|
dir.path(),
|
|
&["run", doc, "--plugin", plugin_path, "--trust-native-plugin"],
|
|
);
|
|
assert_exit(&ungranted, 1, "plugin permission is required");
|
|
assert!(stderr_text(&ungranted).contains("permission.denied"));
|
|
|
|
// Unknown plugin namespace is a hard runtime symbol error.
|
|
dir.write(
|
|
"unknown.mq.md",
|
|
"## @exec main\n\n`结果 = other.add(a=1, b=1)`\n",
|
|
);
|
|
let unknown = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
"unknown.mq.md",
|
|
"--plugin",
|
|
plugin_path,
|
|
"--trust-native-plugin",
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
],
|
|
);
|
|
assert_exit(&unknown, 1, "unknown plugin namespace");
|
|
assert!(stderr_text(&unknown).contains("symbol.unknown"));
|
|
|
|
// The export signature requires both named arguments: with a declared
|
|
// plugin manifest this is rejected statically, before any library load.
|
|
dir.write("args.mq.md", "## @exec main\n\n`结果 = solver.add(a=1)`\n");
|
|
let bad_args = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
"args.mq.md",
|
|
"--plugin",
|
|
plugin_path,
|
|
"--trust-native-plugin",
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
],
|
|
);
|
|
assert_exit(&bad_args, 1, "plugin argument failure");
|
|
assert!(stderr_text(&bad_args).contains("call.arity"));
|
|
assert!(stderr_text(&bad_args).contains("missing required argument `b`"));
|
|
}
|
|
|
|
#[test]
|
|
fn runtime_error_in_imported_module_reports_that_module() {
|
|
let dir = TempDir::new("cross-module-error");
|
|
dir.write(
|
|
"index.mq.md",
|
|
"---\nimport:\n physics: \"./physics.mq.md\"\n---\n\n## @exec main\n\n`打印(physics.boom())`\n",
|
|
);
|
|
dir.write(
|
|
"physics.mq.md",
|
|
"## @exec boom\n\n说明文字。\n\n`x = 1 / 0`\n\n`return x`\n",
|
|
);
|
|
|
|
let output = cli(dir.path(), &["run", "index.mq.md", "--json"]);
|
|
assert_exit(&output, 1, "division by zero is a runtime error");
|
|
let value: serde_json::Value =
|
|
serde_json::from_str(&stdout_text(&output)).expect("run --json emits JSON");
|
|
let error = &value["error"];
|
|
assert_eq!(error["code"], "runtime.division_by_zero");
|
|
assert!(
|
|
error["module_id"]
|
|
.as_str()
|
|
.unwrap_or_default()
|
|
.ends_with("::physics.mq.md"),
|
|
"{}",
|
|
error["module_id"]
|
|
);
|
|
assert_eq!(error["relative_path"], "physics.mq.md");
|
|
assert!(
|
|
error["file"]
|
|
.as_str()
|
|
.unwrap_or_default()
|
|
.ends_with("physics.mq.md"),
|
|
"{}",
|
|
error["file"]
|
|
);
|
|
let line = error["line"].as_u64().unwrap_or(0);
|
|
assert!(line >= 5, "expected the failing statement line, got {line}");
|
|
assert!(
|
|
!error["file"]
|
|
.as_str()
|
|
.unwrap_or_default()
|
|
.ends_with("index.mq.md"),
|
|
"must not blame the entry file"
|
|
);
|
|
|
|
let human = cli(dir.path(), &["run", "index.mq.md"]);
|
|
assert_exit(&human, 1, "human rendering also fails");
|
|
let stderr = stderr_text(&human);
|
|
assert!(stderr.contains("physics.mq.md"), "{stderr}");
|
|
let primary = stderr
|
|
.lines()
|
|
.find(|line| line.trim_start().starts_with("at "))
|
|
.unwrap_or_default();
|
|
assert!(primary.contains("physics.mq.md"), "{primary}");
|
|
}
|
|
|
|
#[test]
|
|
fn platform_reports_strict_capability_truthfully() {
|
|
let root = repo_root();
|
|
let hello = root.join("examples").join("hello.mq.md");
|
|
let output = cli(
|
|
&root,
|
|
&["inspect", hello.to_str().unwrap(), "--platform", "--json"],
|
|
);
|
|
assert_exit(&output, 0, "inspect --platform");
|
|
let value = json_stdout(&output);
|
|
let strict = &value["platform"]["strict"];
|
|
match strict["state"].as_str() {
|
|
Some("available") => {
|
|
assert!(
|
|
strict["mechanism"]
|
|
.as_str()
|
|
.map(|mechanism| mechanism.contains("bubblewrap"))
|
|
.unwrap_or(false),
|
|
"available strict needs the real mechanism: {strict}"
|
|
);
|
|
}
|
|
Some("unavailable") => {
|
|
assert!(
|
|
strict["reason"]
|
|
.as_str()
|
|
.map(|reason| !reason.trim().is_empty())
|
|
.unwrap_or(false),
|
|
"unavailable strict needs an actionable reason: {strict}"
|
|
);
|
|
}
|
|
other => panic!("unexpected strict state: {other:?} ({strict})"),
|
|
}
|
|
assert_eq!(value["platform"]["worker_processes"], true);
|
|
}
|
|
|
|
/// A manifest whose only artifact is for another target must be rejected with
|
|
/// `no_matching_artifact` *before* any library is loaded. This test needs no C
|
|
/// compiler and runs on every platform, including Windows.
|
|
#[test]
|
|
fn plugin_foreign_target_is_rejected_without_loading() {
|
|
let host = host_triple();
|
|
let foreign = if host == "x86_64-unknown-linux-gnu" {
|
|
"aarch64-apple-darwin"
|
|
} else {
|
|
"x86_64-unknown-linux-gnu"
|
|
};
|
|
let dir = TempDir::new("plugin-foreign-target");
|
|
let file = dynamic_library_name();
|
|
dir.write(file, "this is not a shared library");
|
|
let digest = hex::encode(sha2::Sha256::digest(dir.read(file).as_bytes()));
|
|
dir.write(
|
|
"plugin.yaml",
|
|
&format!(
|
|
"plugin:\n name: demo.solver\n version: 0.1.0\n abi: \"^1.0\"\n kind: native\n exports:\n - name: solver.add\n signature: \"($a: Int, $b: Int) -> Int\"\n artifacts:\n - target: {foreign}\n file: {file}\n sha256: \"{digest}\"\n"
|
|
),
|
|
);
|
|
let output = cli(
|
|
dir.path(),
|
|
&["plugin", "inspect", dir.path().to_str().unwrap(), "--json"],
|
|
);
|
|
assert_exit(&output, 1, "foreign artifact target must fail closed");
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["success"], false);
|
|
assert_eq!(value["error"]["code"], "no_matching_artifact");
|
|
let message = value["error"]["message"]
|
|
.as_str()
|
|
.expect("error message is a string");
|
|
assert!(
|
|
message.contains(&host),
|
|
"the diagnostic must name the host target `{host}`: {message}"
|
|
);
|
|
}
|
|
|
|
/// A content-hash mismatch is detected by inspection and the library is never
|
|
/// loaded. The test mutates the built artifact after the manifest was sealed.
|
|
#[test]
|
|
fn plugin_artifact_tampering_is_rejected_before_load() {
|
|
let Some((_dir, plugin_dir)) = build_plugin_copy("plugin-tamper") else {
|
|
return;
|
|
};
|
|
let artifact = plugin_dir.join(dynamic_library_name());
|
|
let mut bytes = fs::read(&artifact).expect("read artifact");
|
|
bytes.push(0);
|
|
fs::write(&artifact, bytes).expect("tamper with artifact");
|
|
|
|
let output = cli(
|
|
repo_root().as_path(),
|
|
&["plugin", "inspect", plugin_dir.to_str().unwrap(), "--json"],
|
|
);
|
|
assert_exit(&output, 1, "tampered artifact must fail closed");
|
|
let value = json_stdout(&output);
|
|
assert_eq!(value["success"], false);
|
|
assert_eq!(value["error"]["code"], "hash_mismatch");
|
|
assert!(value["error"]["message"].as_str().is_some());
|
|
}
|
|
|
|
/// An ABI major mismatch reported by the native library is rejected by
|
|
/// negotiation before any export runs.
|
|
#[test]
|
|
fn plugin_abi_major_mismatch_is_rejected_before_execution() {
|
|
let Some((_dir, plugin_dir)) =
|
|
build_plugin_copy_with("plugin-abi-mismatch", &["-DMQ_SOLVER_REPORT_ABI_MAJOR=2"])
|
|
else {
|
|
return;
|
|
};
|
|
let dir = TempDir::new("plugin-abi-run");
|
|
dir.write(
|
|
"doc.mq.md",
|
|
"## @exec main\n\n`结果 = solver.add(a=20, b=22)`\n\n`打印(结果)`\n",
|
|
);
|
|
let output = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
"doc.mq.md",
|
|
"--plugin",
|
|
plugin_dir.to_str().unwrap(),
|
|
"--trust-native-plugin",
|
|
"--allow-plugin",
|
|
"demo.solver",
|
|
],
|
|
);
|
|
assert_exit(&output, 1, "ABI major mismatch must fail before execution");
|
|
let stderr = stderr_text(&output);
|
|
assert!(
|
|
stderr.contains("abi_major_mismatch"),
|
|
"expected abi_major_mismatch, got: {stderr}"
|
|
);
|
|
assert!(
|
|
!stdout_text(&output).contains("42"),
|
|
"plugin export must not run after an ABI mismatch"
|
|
);
|
|
}
|
|
|
|
/// `check` is static: a document that would run a Foreign kernel must not spawn
|
|
/// it or perform its side effect. The same document is then executed to prove
|
|
/// the marker would appear if check were executing code.
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn check_never_spawns_a_foreign_kernel() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
|
|
let dir = TempDir::new("check-no-exec");
|
|
let marker = dir.path().join("spawned.marker");
|
|
let provider = dir.path().join("mocklang");
|
|
fs::write(
|
|
&provider,
|
|
format!(
|
|
"#!/bin/sh\n: > '{}'\ncat >/dev/null\nprintf '%s' '{{\"type\":\"int\",\"decimal\":\"1\"}}'\n",
|
|
marker.display()
|
|
),
|
|
)
|
|
.expect("write mock provider");
|
|
let mut permissions = fs::metadata(&provider)
|
|
.expect("provider metadata")
|
|
.permissions();
|
|
permissions.set_mode(0o700);
|
|
fs::set_permissions(&provider, permissions).expect("chmod provider");
|
|
let digest = hex::encode(sha2::Sha256::digest(
|
|
fs::read(&provider).expect("read provider"),
|
|
));
|
|
dir.write(
|
|
"kernel.json",
|
|
&format!(
|
|
"{{\"provider_id\":\"mocklang\",\"languages\":[\"mocklang\"],\"wire_version\":1,\"entrypoint\":\"{}\",\"digest\":\"{digest}\"}}",
|
|
provider.display()
|
|
),
|
|
);
|
|
dir.write(
|
|
"doc.mq.md",
|
|
"## @knowledge 代码\n\n```mocklang\nignored\n```\n\n## @exec main\n\n`值 = foreign.call(ref(\"#代码\"), {})`\n\n`打印(值)`\n",
|
|
);
|
|
|
|
let checked = cli(dir.path(), &["check", "doc.mq.md"]);
|
|
assert_exit(&checked, 0, "check must accept the static document");
|
|
assert!(
|
|
!marker.exists(),
|
|
"check spawned the Foreign kernel and produced a side effect"
|
|
);
|
|
|
|
let ran = cli(
|
|
dir.path(),
|
|
&[
|
|
"run",
|
|
"doc.mq.md",
|
|
"--kernel",
|
|
"kernel.json",
|
|
"--allow-foreign",
|
|
],
|
|
);
|
|
assert_exit(&ran, 0, "run must execute the Foreign kernel");
|
|
assert!(
|
|
marker.exists(),
|
|
"run did not execute the provider; the no-execution assertion is vacuous"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn power_branch_loop_and_inert_code_end_to_end() {
|
|
let dir = TempDir::new("power");
|
|
dir.write(
|
|
"branch.mq.md",
|
|
"## @exec main\n\n`n = 2`\n\n`if n ** 2 == 4`\n\n`print(\"乘方正确\")`\n\n`else`\n\n`if n ** 2 != 4`\n\n`print(\"乘方错误\")`\n\n`end`\n\n`end`\n",
|
|
);
|
|
let branch = cli(dir.path(), &["run", "branch.mq.md", "--json"]);
|
|
assert_exit(&branch, 0, "power branch run");
|
|
let value = json_stdout(&branch);
|
|
assert_eq!(value["success"], true);
|
|
assert_eq!(value["stdout"], "乘方正确\n");
|
|
assert_eq!(value["value"]["type"], "unit");
|
|
|
|
dir.write(
|
|
"loop.mq.md",
|
|
"## @exec main\n\n`n = 0`\n\n`limit = 100`\n\n`while n ** 2 < limit`\n\n`n = n + 1`\n\n`end`\n\n`return n`\n",
|
|
);
|
|
let looped = cli(dir.path(), &["run", "loop.mq.md", "--json"]);
|
|
assert_exit(&looped, 0, "power loop run");
|
|
let value = json_stdout(&looped);
|
|
assert_eq!(value["value"]["type"], "int");
|
|
assert_eq!(value["value"]["decimal"], "10");
|
|
|
|
// A code fence containing power syntax is an inert value: it produces no
|
|
// diagnostics and never changes the returned value.
|
|
dir.write(
|
|
"inert.mq.md",
|
|
"## @exec main\n\n```text\n**n = 2 ** 3**\n```\n\n`x = 1`\n\n`return x`\n\n### @knowledge 说明\n\n正文里的 `2 ** 3` 不执行。\n",
|
|
);
|
|
let inert = cli(dir.path(), &["run", "inert.mq.md", "--json"]);
|
|
assert_exit(&inert, 0, "inert code run");
|
|
let value = json_stdout(&inert);
|
|
assert_eq!(value["value"]["decimal"], "1");
|
|
}
|
|
|
|
#[test]
|
|
fn condition_parse_diagnostic_points_inside_the_code_span() {
|
|
let dir = TempDir::new("condition-span");
|
|
let source = "## @exec main\n\n`n = 2`\n\n`if n ** 2 ==`\n\n`print(1)`\n\n`end`\n";
|
|
dir.write("bad.mq.md", source);
|
|
let output = cli(dir.path(), &["check", "bad.mq.md", "--json"]);
|
|
assert_exit(&output, 1, "condition parse error");
|
|
let value = json_stdout(&output);
|
|
let diagnostic = value["diagnostics"]
|
|
.as_array()
|
|
.expect("diagnostics array")
|
|
.iter()
|
|
.find(|diagnostic| diagnostic["code"] == "sem.syntax")
|
|
.expect("sem.syntax diagnostic");
|
|
assert_eq!(diagnostic["line"], 5);
|
|
// The payload span is mapped onto the file; it must point inside the
|
|
// carrier rather than at the heading or a delimiter.
|
|
let column = diagnostic["column"].as_u64().expect("column");
|
|
assert!((11..=14).contains(&column), "unexpected column {column}");
|
|
}
|
|
|
|
#[test]
|
|
fn run_reports_sem_no_entry_function_without_exec_main() {
|
|
let dir = TempDir::new("no-entry");
|
|
dir.write(
|
|
"index.mq.md",
|
|
"# @knowledge 文档\n\n这里没有可调用的函数。\n",
|
|
);
|
|
let output = cli(dir.path(), &["run", "index.mq.md"]);
|
|
assert_exit(&output, 1, "missing Exec H2 main is an error");
|
|
let stderr = stderr_text(&output);
|
|
assert!(
|
|
stderr.contains("sem.no_entry_function"),
|
|
"stderr must carry the stable code: {stderr}"
|
|
);
|
|
}
|