Files
marqdo/tests/stdlib_tasks.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

1276 lines
39 KiB
Rust
Executable File

//! Exercise public documents on both runtimes; no private host-only shortcuts.
use serde_json::{json, Value};
use std::{
fs,
path::{Path, PathBuf},
process::Command,
sync::atomic::{AtomicU64, Ordering},
};
static SEQ: AtomicU64 = AtomicU64::new(0);
fn root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
}
struct Scratch(PathBuf);
impl Scratch {
fn new() -> Self {
let p = std::env::temp_dir().join(format!(
"mq-stdlib-{}-{}",
std::process::id(),
SEQ.fetch_add(1, Ordering::Relaxed)
));
fs::create_dir_all(&p).unwrap();
Self(p)
}
}
impl Drop for Scratch {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
fn call(
backend: &str,
module: &str,
function: &str,
args: &[&str],
effects: &str,
dir: Option<&Path>,
) -> Value {
let mut c = Command::new(env!("CARGO_BIN_EXE_marqdo"));
c.current_dir(root())
.args(["call", "--json", "--backend", backend, "--effects", effects]);
if let Some(dir) = dir {
c.arg("--fs-root").arg(dir);
}
let out = c.arg(module).arg(function).args(args).output().unwrap();
serde_json::from_slice(&out.stdout).unwrap_or_else(|e| {
panic!(
"{module} {function}: {e}: {} {}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
)
})
}
fn ok(v: Value) -> Value {
assert_eq!(v["ok"], true, "{v}");
v["result"].clone()
}
#[test]
fn field_transforms_and_table_shapes_are_real_public_tools() {
for backend in ["tree", "bytecode"] {
let m = "lib/table.mq.md";
assert_eq!(
ok(call(
backend,
m,
"range",
&["start=5", "end=0", "step=-2"],
"none",
None
)),
json!([5, 3, 1])
);
let rows =
"list=[{\"team\":\"a\",\"n\":3},{\"team\":\"b\",\"n\":1},{\"team\":\"a\",\"n\":2}]";
assert_eq!(
ok(call(
backend,
m,
"pluck",
&[rows, "key=\"n\""],
"none",
None
)),
json!([3, 1, 2])
);
let groups = ok(call(
backend,
m,
"group_by",
&[rows, "key=\"team\""],
"none",
None,
));
assert_eq!(groups[0]["count"], 2);
assert_eq!(groups[1]["key"], "b");
assert_eq!(
ok(call(
backend,
m,
"aggregate",
&[rows, "key=\"n\""],
"none",
None
)),
6
);
assert_eq!(
ok(call(
backend,
m,
"where",
&[rows, "key=\"n\"", "value=2", "op=\"ge\""],
"none",
None
))
.as_array()
.unwrap()
.len(),
2
);
assert_eq!(
ok(call(
backend,
m,
"from_columns",
&["columns={\"a\":[1,2],\"b\":[3,4]}"],
"none",
None
)),
json!([{"a":1,"b":3},{"a":2,"b":4}])
);
assert_eq!(
call(
backend,
m,
"from_columns",
&["columns={\"a\":[1],\"b\":[3,4]}"],
"none",
None
)["ok"],
false
);
let joined = ok(call(
backend,
m,
"join",
&[
"a=[{\"id\":1,\"name\":\"left\"},{\"id\":2,\"name\":\"only\"}]",
"b=[{\"id\":1,\"name\":\"right\"}]",
"key=\"id\"",
"right_key=\"id\"",
"mode=\"left\"",
],
"none",
None,
));
assert_eq!(joined[0]["right_name"], "right");
assert_eq!(joined[1]["right_name"], Value::Null);
assert_eq!(
ok(call(
backend,
m,
"cast",
&[
"rows=[{\"n\":\"42\",\"yes\":\"true\"}]",
"schema={\"n\":\"int\",\"yes\":\"bool\"}"
],
"none",
None
)),
json!([{"n":42,"yes":true}])
);
assert_eq!(
ok(call(
backend,
"lib/表.mq.md",
"分组",
&[&rows.replace("list=", "列表="), "键=\"team\""],
"none",
None
)),
groups
);
assert_eq!(
ok(call(
backend,
"lib/path.mq.md",
"with_extension",
&["path=\"a/b.txt\"", "extension=\"md\""],
"none",
None
)),
"a/b.md"
);
}
}
#[test]
fn file_tasks_cover_binary_chunks_atomicity_and_conflicts() {
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
let dir = Some(scratch.0.as_path());
let m = "lib/fs.mq.md";
fs::write(scratch.0.join("binary"), [0u8, 255, 128]).unwrap();
let bytes = ok(call(
backend,
m,
"read_bytes",
&["path=\"binary\""],
"fs.read",
dir,
));
assert_eq!(bytes, json!({"_type":"bytes","base64":"AP+A"}));
let chunk = ok(call(
backend,
m,
"read_chunk",
&["path=\"binary\"", "offset=1", "size=1"],
"fs.read",
dir,
));
assert_eq!(chunk["data"]["base64"], "/w==");
assert_eq!(chunk["next_offset"], 2);
assert_eq!(chunk["eof"], false);
ok(call(
backend,
m,
"write_bytes",
&[
"path=\"copy\"",
"data={\"_type\":\"bytes\",\"base64\":\"AP+A\"}",
],
"fs.write",
dir,
));
assert_eq!(fs::read(scratch.0.join("copy")).unwrap(), [0, 255, 128]);
assert_eq!(
call(backend, m, "exists", &["path=\"copy\""], "none", dir)["error"]["code"],
"artifact.effect_denied"
);
ok(call(
backend,
m,
"atomic_write",
&["path=\"nested/a.txt\"", "text=\"old\""],
"fs.write",
dir,
));
assert_eq!(
ok(call(
backend,
m,
"write_changed",
&["path=\"nested/a.txt\"", "text=\"old\""],
"fs.write",
dir
)),
false
);
let conflict = ok(call(
backend,
m,
"write_checked",
&[
"path=\"nested/a.txt\"",
"text=\"new\"",
"expected_sha256=\"wrong\"",
],
"fs.write",
dir,
));
assert_eq!(conflict["error"]["code"], "conflict");
assert_eq!(
fs::read_to_string(scratch.0.join("nested/a.txt")).unwrap(),
"old"
);
let result = ok(call(
backend,
m,
"try_read_text",
&["path=\"missing\""],
"fs.read",
dir,
));
assert_eq!(result["ok"], false);
assert_eq!(result["error"]["code"], "not_found");
let found = ok(call(
backend,
m,
"find",
&["path=\".\"", "pattern=\"**/*.txt\""],
"fs.read",
dir,
));
assert_eq!(found, json!(["nested/a.txt"]));
assert_eq!(
call(
backend,
m,
"remove_file",
&["path=\"nested\""],
"fs.write",
dir
)["ok"],
false
);
assert!(scratch.0.join("nested/a.txt").exists());
let planned = ok(call(
backend,
m,
"copy_tree",
&["src=\"nested\"", "dest=\"backup\"", "dry_run=True"],
"fs.write",
dir,
));
assert_eq!(planned, json!(["a.txt"]));
assert!(!scratch.0.join("backup").exists());
ok(call(
backend,
m,
"copy_tree",
&["src=\"nested\"", "dest=\"backup\""],
"fs.write",
dir,
));
assert_eq!(
fs::read_to_string(scratch.0.join("backup/a.txt")).unwrap(),
"old"
);
assert_eq!(
ok(call(
backend,
m,
"sync_tree",
&["src=\"nested\"", "dest=\"backup\""],
"fs.write",
dir
)),
json!([])
);
assert_eq!(
call(
backend,
m,
"read_text",
&["path=\"../outside\""],
"fs.read",
dir
)["ok"],
false
);
}
}
#[test]
fn effects_follow_host_identity_through_aliases_and_chinese() {
let scratch = Scratch::new();
let library = root().join("lib/文件.mq.md");
let source=format!("---\nmarkup: occlusion\nimport:\n disk: {}\n---\n\n## query\n\n*> disk.存在 路径=\"a.txt\"*\n",library.display());
let file = scratch.0.join("caller.mq.md");
fs::write(&file, source).unwrap();
fs::write(scratch.0.join("a.txt"), "a").unwrap();
for backend in ["tree", "bytecode"] {
let file = file.to_str().unwrap();
assert_eq!(
call(backend, file, "query", &[], "none", None)["error"]["code"],
"artifact.effect_denied"
);
assert_eq!(ok(call(backend, file, "query", &[], "fs.read", None)), true);
assert_eq!(
call(
backend,
"lib/文件.mq.md",
"存在",
&["路径=\"a.txt\""],
"none",
Some(&scratch.0)
)["error"]["code"],
"artifact.effect_denied"
);
}
}
#[cfg(unix)]
#[test]
fn sandbox_rejects_symlink_escapes_even_for_new_descendants() {
use std::os::unix::fs::symlink;
let inside = Scratch::new();
let outside = Scratch::new();
symlink(&outside.0, inside.0.join("escape")).unwrap();
for backend in ["tree", "bytecode"] {
assert_eq!(
call(
backend,
"lib/fs.mq.md",
"write_text",
&["path=\"escape/new/a.txt\"", "text=\"no\""],
"fs.write",
Some(&inside.0)
)["ok"],
false
);
assert!(!outside.0.join("new").exists());
}
}
#[test]
fn inert_documents_preserve_surrounding_source_and_reject_ambiguity() {
let source="---\ntitle: sample\n---\n\n# Intro\n\nkeep\n\n## Data\n\n| item | n |\n|---|---|\n| a | 2 |\n\n```mq\n> fs.remove_tree path=\".\"\n# not a heading\n```\n\n# End\n\nleave me\n";
for backend in ["tree", "bytecode"] {
let text = format!("text=\"{source}\"");
let sections = ok(call(
backend,
"lib/document.mq.md",
"sections",
&[&text],
"none",
None,
));
assert_eq!(sections.as_array().unwrap().len(), 3);
let tables = ok(call(
backend,
"lib/document.mq.md",
"tables",
&[&text],
"none",
None,
));
assert_eq!(tables[0]["headers"], json!(["item", "n"]));
assert_eq!(tables[0]["rows"], json!([["a", "2"]]));
let code = ok(call(
backend,
"lib/document.mq.md",
"code_blocks",
&[&text],
"none",
None,
));
assert!(code[0]["text"].as_str().unwrap().contains("remove_tree"));
let result = ok(call(
backend,
"lib/document.mq.md",
"replace_section",
&[&text, "title=\"Data\"", "body=\"replacement\""],
"none",
None,
));
assert_eq!(result["ok"], true);
let changed = result["value"].as_str().unwrap();
assert!(changed.starts_with("---\ntitle: sample\n---\n\n# Intro\n\nkeep"));
assert!(changed.ends_with("# End\n\nleave me\n"));
assert!(changed.contains("## Data\n\nreplacement\n"));
let replaced = ok(call(
backend,
"lib/document.mq.md",
"replace_table",
&[
&text,
"index=0",
"headers=[\"item\",\"n\"]",
"rows=[[\"b\",\"3\"]]",
],
"none",
None,
));
assert_eq!(replaced["ok"], true);
assert!(replaced["value"]
.as_str()
.unwrap()
.contains("# not a heading"));
let conflict = ok(call(
backend,
"lib/document.mq.md",
"replace_section",
&[
&text,
"title=\"Data\"",
"body=\"x\"",
"expected_sha256=\"stale\"",
],
"none",
None,
));
assert_eq!(conflict["error"]["code"], "conflict");
}
}
#[test]
fn timezone_dst_and_full_toml_have_explicit_data_boundaries() {
for backend in ["tree", "bytecode"] {
let gap = ok(call(
backend,
"lib/datetime.mq.md",
"parse_local",
&["text=\"2024-03-10 02:30:00\"", "zone=\"America/New_York\""],
"none",
None,
));
assert_eq!(gap["ok"], false);
let args = [
"text=\"2024-11-03 01:30:00\"",
"zone=\"America/New_York\"",
"ambiguity=\"earliest\"",
];
let early = ok(call(
backend,
"lib/datetime.mq.md",
"parse_local",
&args,
"none",
None,
));
let late = ok(call(
backend,
"lib/datetime.mq.md",
"parse_local",
&[args[0], args[1], "ambiguity=\"latest\""],
"none",
None,
));
assert_eq!(
late["value"]["unix"].as_i64().unwrap() - early["value"]["unix"].as_i64().unwrap(),
3600
);
let before = ok(call(
backend,
"lib/datetime.mq.md",
"parse_local",
&["text=\"2024-03-09 12:00:00\"", args[1]],
"none",
None,
));
let dt = format!("dt={}", before["value"]);
let after = ok(call(
backend,
"lib/datetime.mq.md",
"add_calendar",
&[&dt, "days=1"],
"none",
None,
));
assert_eq!(
after["value"]["unix"].as_i64().unwrap() - before["value"]["unix"].as_i64().unwrap(),
23 * 3600
);
let elapsed = ok(call(
backend,
"lib/datetime.mq.md",
"add",
&[&dt, "days=1"],
"none",
None,
));
assert!(elapsed["iso"].as_str().unwrap().contains("13:00:00-04:00"));
let toml="text=\"[app]\ninline = { ok = true }\n[[workers]]\nname = 'one'\n[[workers]]\nname = 'two'\n\"";
let parsed = ok(call(
backend,
"lib/toml.mq.md",
"parse",
&[toml],
"none",
None,
));
assert_eq!(parsed["workers"].as_array().unwrap().len(), 2);
assert_eq!(parsed["app"]["inline"]["ok"], true);
let value = format!("value={parsed}");
let rendered = ok(call(
backend,
"lib/toml.mq.md",
"stringify",
&[&value],
"none",
None,
));
let text = format!("text=\"{}\"", rendered.as_str().unwrap());
assert_eq!(
ok(call(
backend,
"lib/toml.mq.md",
"parse",
&[&text],
"none",
None
)),
parsed
);
}
}
#[test]
fn bounded_file_batch_inherits_parent_permissions_and_returns_ordered_results() {
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
fs::write(scratch.0.join("one.mq.md"), "# main\n\n*1*\n").unwrap();
fs::write(scratch.0.join("two.mq.md"), "# main\n\n*2*\n").unwrap();
fs::write(scratch.0.join("write.mq.md"),format!("---\nimport:\n fs: {}\n---\n# main\n\n> fs.write_text path=forbidden text=no\n*3*\n",root().join("lib/fs.mq.md").display())).unwrap();
let results=ok(call(backend,"lib/subtask.mq.md","run_many",&["tasks=[{\"path\":\"one.mq.md\"},{\"path\":\"two.mq.md\"},{\"path\":\"write.mq.md\"}]","limit=2"],"process.exec",Some(&scratch.0)));
assert_eq!(results[0]["value"]["value"], 1);
assert_eq!(results[1]["value"]["value"], 2);
assert_ne!(results[2]["value"]["code"], 0);
assert!(!scratch.0.join("forbidden").exists());
}
}
fn public_standard_libraries() -> Vec<PathBuf> {
let mut files: Vec<_> = fs::read_dir(root().join("lib"))
.unwrap()
.map(|entry| entry.unwrap().path())
.filter(|path| path.is_file() && path.to_string_lossy().ends_with(".mq.md"))
.collect();
files.sort();
files
}
#[test]
fn single_file_source_examples_execute_on_both_backends() {
let guides = public_standard_libraries();
assert!(guides.len() >= 60, "missing standard library sources");
for path in guides {
let source = fs::read_to_string(&path).unwrap();
let mut shell = false;
let mut commands = Vec::new();
for line in source.lines() {
if line == "```sh" {
shell = true
} else if line == "```" {
shell = false
} else if shell && !line.trim().is_empty() {
commands.push(line.to_string());
}
}
assert!(
!commands.is_empty(),
"{} lacks an executable recipe",
path.display()
);
let errors = marqdo::check::check_path(&path).unwrap();
assert!(errors.is_empty(), "{}: {errors:?}", path.display());
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
fs::create_dir(scratch.0.join("input")).unwrap();
fs::write(scratch.0.join("input/note.txt"), "Archive example").unwrap();
for command in &commands {
assert!(command.starts_with("marqdo call "), "{command}");
let command = command.replacen(
"marqdo call ",
&format!(
"\"{}\" call --backend {backend} ",
env!("CARGO_BIN_EXE_marqdo")
),
1,
);
let out = Command::new("bash")
.args(["--noprofile", "--norc", "-ec", &command])
.env_remove("BASH_ENV")
.env("MQ_WORK", &scratch.0)
.current_dir(root())
.output()
.unwrap();
assert!(
out.status.success(),
"{} [{backend}] {command}: {} {}",
path.display(),
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
let body: Value = serde_json::from_slice(&out.stdout).unwrap();
assert_eq!(body["ok"], true, "{body}");
if body["result"]["ok"].is_boolean() {
assert_eq!(
body["result"]["ok"], true,
"example returned failure: {body}"
);
}
}
}
}
}
#[test]
fn complete_engineering_example_runs_in_a_disposable_root() {
for backend in ["tree", "bytecode"] {
for (file, function) in [
("examples/stdlib-handbook/index.mq.md", "demo"),
("examples/stdlib-handbook/索引.mq.md", "演示"),
] {
let scratch = Scratch::new();
let result = ok(call(
backend,
file,
function,
&[],
"fs.write",
Some(&scratch.0),
));
let files = result["inventory"].as_array().unwrap();
assert_eq!(files.len(), 2);
assert_eq!(files.iter().filter(|row| row["ok"] == true).count(), 1);
assert_eq!(files.iter().filter(|row| row["ok"] == false).count(), 1);
assert!(result["csv"].as_str().unwrap().contains("a,30,2"));
assert_eq!(result["update"]["ok"], true);
let document = result["document"].as_str().unwrap();
assert!(document.contains("Updated through public"));
assert!(document.contains("# Appendix\n\nKeep this paragraph."));
assert_eq!(
fs::read_dir(&scratch.0).unwrap().count(),
0,
"demo leaked its temporary tree"
);
}
}
}
#[test]
fn optional_zip_roundtrip_and_expansion_preflight() {
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
let dir = Some(scratch.0.as_path());
fs::create_dir(scratch.0.join("input")).unwrap();
fs::write(scratch.0.join("input/data.bin"), [0u8, 255]).unwrap();
let packed = ok(call(
backend,
"lib/archive.mq.md",
"pack",
&["src=\"input\"", "dest=\"bundle.zip\""],
"fs.write",
dir,
));
assert_eq!(packed["ok"], true);
let limited = ok(call(
backend,
"lib/archive.mq.md",
"unpack",
&["src=\"bundle.zip\"", "dest=\"too-large\"", "max_bytes=1"],
"fs.write",
dir,
));
assert_eq!(limited["ok"], false);
assert!(!scratch.0.join("too-large").exists());
let unpacked = ok(call(
backend,
"lib/archive.mq.md",
"unpack",
&["src=\"bundle.zip\"", "dest=\"output\""],
"fs.write",
dir,
));
assert_eq!(unpacked["ok"], true);
assert_eq!(
fs::read(scratch.0.join("output/data.bin")).unwrap(),
[0, 255]
);
}
}
#[test]
fn http_results_keep_status_headers_and_binary_downloads() {
use std::{
io::{Read, Write},
net::TcpListener,
thread,
time::Duration,
};
for backend in ["tree", "bytecode"] {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let server = thread::spawn(move || {
for i in 0..4 {
let (mut socket, _) = listener.accept().unwrap();
socket
.set_read_timeout(Some(Duration::from_secs(5)))
.unwrap();
let mut buffer = [0u8; 4096];
let _ = socket.read(&mut buffer);
let body = if i == 2 || i == 3 {
vec![0u8, 255, 128]
} else {
b"ready".to_vec()
};
let status = if i == 1 { "404 Not Found" } else { "200 OK" };
let header=format!("HTTP/1.1 {status}\r\nContent-Length: {}\r\nX-Example: yes\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\nConnection: close\r\n\r\n",body.len());
socket.write_all(header.as_bytes()).unwrap();
socket.write_all(&body).unwrap();
}
});
let url = format!("url=\"http://{addr}/sample\"");
let response = ok(call(
backend,
"lib/net.mq.md",
"get",
&[&url],
"network.read",
None,
));
assert_eq!(response["ok"], true);
assert_eq!(response["value"]["status"], 200);
assert_eq!(response["value"]["body"], "ready");
assert_eq!(
response["value"]["headers"]
.as_array()
.unwrap()
.iter()
.find(|row| row["name"] == "set-cookie")
.unwrap()["values"]
.as_array()
.unwrap()
.len(),
2
);
let response = ok(call(
backend,
"lib/net.mq.md",
"get",
&[&url],
"network.read",
None,
));
assert_eq!(response["ok"], true);
assert_eq!(response["value"]["status"], 404);
let response = ok(call(
backend,
"lib/net.mq.md",
"get",
&[&url, "response=\"bytes\""],
"network.read",
None,
));
assert_eq!(response["value"]["body"]["base64"], "AP+A");
let scratch = Scratch::new();
let download = ok(call(
backend,
"lib/net.mq.md",
"download",
&[&url, "path=\"download.bin\""],
"network.read,fs.write",
Some(&scratch.0),
));
assert_eq!(download["ok"], true);
assert_eq!(
fs::read(scratch.0.join("download.bin")).unwrap(),
[0, 255, 128]
);
server.join().unwrap();
}
}
#[test]
fn timeout_retains_a_handle_until_the_caller_chooses_to_join() {
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
fs::write(
scratch.0.join("child.mq.md"),
format!(
"---\nimport:\n time: {}\n---\n# main\n\n> time.sleep_ms ms=100\n*17*\n",
root().join("lib/time.mq.md").display()
),
)
.unwrap();
let source=format!("---\nmarkup: occlusion\nimport:\n task: {}\n---\n\n## example\n\n**id = task.spawn path=\"child.mq.md\"**\n**early = task.wait_timeout id=`id` timeout_ms=1**\n**late = task.wait_timeout id=`id` timeout_ms=2000 cancel=True**\n`out` =\n\n| early | late |\n|---|---|\n| `early` | `late` |\n\n*out*\n",root().join("lib/subtask.mq.md").display());
let parent = scratch.0.join("parent.mq.md");
fs::write(&parent, source).unwrap();
let value = ok(call(
backend,
parent.to_str().unwrap(),
"example",
&[],
"process.exec",
None,
));
assert_eq!(value["early"]["error"]["code"], "timed_out");
assert_eq!(value["late"]["ok"], true);
assert_eq!(value["late"]["value"]["value"], 17);
}
}
#[test]
fn validation_set_operations_and_batch_aggregation_share_collection_semantics() {
for backend in ["tree", "bytecode"] {
let m = "lib/table.mq.md";
assert_eq!(
ok(call(
backend,
m,
"union",
&["a=[1,2,1]", "b=[2,3]"],
"none",
None
)),
json!([1, 2, 3])
);
let validation = ok(call(
backend,
m,
"validate",
&[
"rows=[{\"n\":1},{\"n\":\"bad\"},{}]",
"schema={\"n\":\"number\"}",
],
"none",
None,
));
assert_eq!(validation["error"]["code"], "validation_failed");
assert_eq!(validation["error"]["details"].as_array().unwrap().len(), 2);
let cast = ok(call(
backend,
m,
"try_cast",
&["rows=[{\"n\":\"bad\"}]", "schema={\"n\":\"int\"}"],
"none",
None,
));
assert_eq!(cast["ok"], false);
let summary = ok(call(
backend,
m,
"summarize",
&[
"list=[{\"team\":\"a\",\"n\":1},{\"team\":\"a\",\"n\":2},{\"team\":\"b\",\"n\":4}]",
"key=\"team\"",
"field=\"n\"",
],
"none",
None,
));
assert_eq!(
summary,
json!([{"key":"a","count":2,"value":3},{"key":"b","count":1,"value":4}])
);
}
}
#[test]
fn invalid_http_options_send_nothing_and_failed_download_keeps_original() {
use std::{
io::{Read, Write},
net::TcpListener,
thread,
time::Duration,
};
for backend in ["tree", "bytecode"] {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let url = format!("url=\"http://{}/\"", listener.local_addr().unwrap());
let result = ok(call(
backend,
"lib/net.mq.md",
"request",
&[
&url,
"method=\"POST\"",
"body=\"must not send\"",
"response=\"invalid\"",
],
"network.write",
None,
));
assert_eq!(result["error"]["code"], "invalid_argument");
assert!(
matches!(listener.accept(),Err(error) if error.kind()==std::io::ErrorKind::WouldBlock)
);
let scratch = Scratch::new();
let result = ok(call(
backend,
"lib/net.mq.md",
"download",
&[&url, "path=\"../escape.bin\""],
"network.read,fs.write",
Some(&scratch.0),
));
assert_eq!(result["error"]["code"], "permission_denied");
assert!(
matches!(listener.accept(),Err(error) if error.kind()==std::io::ErrorKind::WouldBlock)
);
listener.set_nonblocking(false).unwrap();
let server = thread::spawn(move || {
let (mut socket, _) = listener.accept().unwrap();
socket
.set_read_timeout(Some(Duration::from_secs(5)))
.unwrap();
let mut request = [0u8; 2048];
let _ = socket.read(&mut request);
socket
.write_all(
b"HTTP/1.1 200 OK\r\nContent-Length: 8\r\nConnection: close\r\n\r\n12345678",
)
.unwrap();
});
fs::write(scratch.0.join("saved.bin"), "keep").unwrap();
let result = ok(call(
backend,
"lib/net.mq.md",
"download",
&[&url, "path=\"saved.bin\"", "max_bytes=3"],
"network.read,fs.write",
Some(&scratch.0),
));
assert_eq!(result["error"]["code"], "resource_limit");
assert_eq!(fs::read(scratch.0.join("saved.bin")).unwrap(), b"keep");
assert_eq!(fs::read_dir(&scratch.0).unwrap().count(), 1);
server.join().unwrap();
}
}
#[test]
fn zip_preflight_rejects_escaping_and_symlink_entries() {
use std::io::Write;
for backend in ["tree", "bytecode"] {
let scratch = Scratch::new();
let file = fs::File::create(scratch.0.join("escaping.zip")).unwrap();
let mut zip = zip::ZipWriter::new(file);
zip.start_file("../outside.txt", zip::write::FileOptions::default())
.unwrap();
zip.write_all(b"no").unwrap();
zip.finish().unwrap();
let failed = ok(call(
backend,
"lib/archive.mq.md",
"unpack",
&["src=\"escaping.zip\"", "dest=\"escaped\""],
"fs.write",
Some(&scratch.0),
));
assert_eq!(failed["ok"], false);
assert!(!scratch.0.join("escaped").exists());
let file = fs::File::create(scratch.0.join("symlink.zip")).unwrap();
let mut zip = zip::ZipWriter::new(file);
zip.add_symlink("link", "../../target", zip::write::FileOptions::default())
.unwrap();
zip.finish().unwrap();
let failed = ok(call(
backend,
"lib/archive.mq.md",
"unpack",
&["src=\"symlink.zip\"", "dest=\"links\""],
"fs.write",
Some(&scratch.0),
));
assert_eq!(failed["ok"], false);
assert!(!scratch.0.join("links").exists());
}
}
#[test]
fn every_standard_library_is_its_own_readable_handbook() {
let files = public_standard_libraries();
assert!(files.len() >= 60);
for path in files {
let text = fs::read_to_string(&path).unwrap();
assert!(
!text
.lines()
.any(|line| line.trim_start().starts_with("+ `")),
"{} retains legacy parameters",
path.display()
);
for line in text
.lines()
.filter(|line| line.contains("host_") && line.trim_start().starts_with('*'))
{
assert!(
line.contains("]("),
"{} has an opaque unlabeled instruction: {line}",
path.display()
);
}
let module = marqdo::load::load_module(&path).unwrap();
assert!(
!module.functions.is_empty(),
"empty library: {}",
path.display()
);
let diagnostics = marqdo::check::check_path(&path).unwrap();
assert!(
diagnostics.is_empty(),
"{}: {diagnostics:?}",
path.display()
);
let reports = marqdo::narrative_ratio::measure_source_units(&text, &module.functions);
for report in &reports {
assert!(
report.ratio > 0.5,
"{} {} has {:.1}% narrative",
path.display(),
report.name,
report.ratio * 100.0
);
}
for function in &module.functions {
assert!(
function.params.iter().all(|p| p.inferred),
"{} {} retains explicit parameters",
path.display(),
function.name
);
let contract = function
.contract
.as_ref()
.unwrap_or_else(|| panic!("{} {} lacks a contract", path.display(), function.name));
assert!(
contract.returns.is_some(),
"{} {} lacks a return contract",
path.display(),
function.name
);
assert_eq!(
contract.params.len(),
function.params.len(),
"{} {} incomplete parameter table",
path.display(),
function.name
);
let first = text
.lines()
.skip(function.span.line as usize)
.find(|line| !line.trim().is_empty())
.unwrap();
assert!(
first.starts_with(if function.params.is_empty() {
"| 返回 |"
} else {
"| 参数 |"
}),
"{} {} must put its contract table directly below the heading",
path.display(),
function.name
);
}
}
}
#[test]
fn large_indices_and_chunk_sizes_have_portable_meaning() {
for backend in ["tree", "bytecode"] {
let table = "lib/table.mq.md";
assert_eq!(
ok(call(
backend,
table,
"at",
&["xs=[1,2]", "i=4294967296"],
"none",
None
)),
Value::Null
);
assert_eq!(
ok(call(
backend,
table,
"chunk",
&["list=[1,2]", "size=4294967296"],
"none",
None
)),
json!([[1, 2]])
);
assert_eq!(
call(
backend,
table,
"put",
&["in=[1,2]", "at=[4294967296,1]", "value=9"],
"none",
None
)["ok"],
false
);
for operation in ["insert", "set_at"] {
assert_eq!(
call(
backend,
table,
operation,
&["list=[1,2]", "index=4294967296", "item=9"],
"none",
None
)["ok"],
false
);
}
let bytes = ok(call(
backend,
"lib/bytes.mq.md",
"slice",
&[
"data={\"_type\":\"bytes\",\"base64\":\"AP+A\"}",
"start=4294967296",
"end=4294967298",
],
"none",
None,
));
assert_eq!(bytes["base64"], "");
}
}
#[test]
fn library_development_guide_examples_match_their_contracts() {
let file = "doc/library-development.mq.md";
let source = fs::read_to_string(root().join(file)).unwrap();
let module = marqdo::load::load_module(&root().join(file)).unwrap();
assert_eq!(
module
.functions
.iter()
.map(|f| f.name.as_str())
.collect::<Vec<_>>(),
["计算金额", "形成订单摘要", "尝试读取正文"]
);
assert!(marqdo::check::check_path(&root().join(file))
.unwrap()
.is_empty());
for report in marqdo::narrative_ratio::measure_source_units(&source, &module.functions) {
assert!(
report.ratio > 0.5,
"{} has {:.1}% narrative",
report.name,
report.ratio * 100.0
);
}
let recipe = source
.split("```sh\n")
.nth(1)
.unwrap()
.split("\n```")
.next()
.unwrap();
let commands: Vec<_> = recipe.lines().collect();
assert_eq!(commands.len(), 3);
for backend in ["tree", "bytecode"] {
let mut results = Vec::new();
for command in &commands {
let command = command.replacen(
"marqdo call ",
&format!(
"\"{}\" call --backend {backend} ",
env!("CARGO_BIN_EXE_marqdo")
),
1,
);
let output = Command::new("bash")
.args(["--noprofile", "--norc", "-ec", &command])
.env_remove("BASH_ENV")
.current_dir(root())
.output()
.unwrap();
assert!(
output.status.success(),
"{backend}: {command}: {}",
String::from_utf8_lossy(&output.stderr)
);
results.push(ok(serde_json::from_slice(&output.stdout).unwrap()));
}
assert_eq!(results[0], 36);
assert_eq!(results[1], json!({"商品":"笔记本","数量":3,"金额":36}));
assert_eq!(results[2]["ok"], true);
assert_eq!(results[2]["value"], source);
assert_eq!(
ok(call(backend, file, "计算金额", &["单价=12"], "none", None)),
12
);
let scratch = Scratch::new();
let missing = ok(call(
backend,
file,
"尝试读取正文",
&["路径=\"missing.md\""],
"fs.read",
Some(&scratch.0),
));
assert_eq!(missing["ok"], false);
assert_eq!(missing["error"]["code"], "not_found");
assert_eq!(
call(
backend,
file,
"尝试读取正文",
&["路径=\"missing.md\""],
"none",
Some(&scratch.0)
)["ok"],
false
);
}
}