//! Product-level tests for the whole bundled `marqdo-stdlib` tree. //! //! Every public module in `stdlib/README.md` has a `.mq.md` self-test under //! `stdlib/tests/`, and this lane runs the whole directory through the real //! user import path (`std:` + the verified bundle), not through a conformance //! fixture or a Rust shortcut. use std::io::Write; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; use std::sync::{Mutex, MutexGuard}; fn repo_root() -> PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")) .parent() .unwrap() .parent() .unwrap() .to_path_buf() } static FS_LOCK: Mutex<()> = Mutex::new(()); fn lock_fs(name: &str) -> Option> { if name == "fs.mq.md" { Some(FS_LOCK.lock().unwrap_or_else(|error| error.into_inner())) } else { None } } fn stdlib_dir() -> PathBuf { repo_root().join("stdlib") } struct TestFile { name: String, stdin: &'static str, stdout: &'static str, args: &'static [&'static str], } fn product_tests() -> Vec { let dir = stdlib_dir().join("tests"); let mut files: Vec = std::fs::read_dir(&dir) .expect("read stdlib tests") .map(|entry| { let path = entry.unwrap().path(); if !path.is_file() { return TestFile { name: String::new(), stdin: "", stdout: "", args: &[], }; } let name = path.file_name().unwrap().to_string_lossy().to_string(); let (stdin, stdout) = match name.as_str() { "console.mq.md" => ("hello\n", ""), "io.mq.md" => ("", "stdlib self-test\n"), "stream.mq.md" => ("", "stream\n"), _ => ("", ""), }; let args = if name == "fs.mq.md" { &[ "--allow-read", "out", "--allow-read", "out/**", "--allow-write", "out", "--allow-write", "out/**", ][..] } else { &[][..] }; TestFile { name, stdin, stdout, args, } }) .filter(|file| !file.name.is_empty()) .collect(); files.sort_by(|left, right| left.name.cmp(&right.name)); files } fn run_product_test(file: &TestFile) -> serde_json::Value { if file.name == "fs.mq.md" { let _ = std::fs::remove_dir_all(stdlib_dir().join("tests/out")); } let mut child = Command::new(env!("CARGO_BIN_EXE_marqdo")) .args(["run"]) .arg(stdlib_dir().join("tests").join(&file.name)) .args(file.args) .args(["--json"]) .current_dir(stdlib_dir()) .env("MARQDO_STDLIB_DIR", stdlib_dir()) .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::piped()) .spawn() .expect("spawn marqdo"); child .stdin .as_mut() .unwrap() .write_all(file.stdin.as_bytes()) .unwrap(); let output = child.wait_with_output().expect("wait marqdo"); assert_eq!( output.status.code(), Some(0), "{} failed: {}", file.name, String::from_utf8_lossy(&output.stderr) ); serde_json::from_slice(&output.stdout).expect("json report") } #[test] fn every_public_stdlib_module_has_a_product_test() { let names: Vec = product_tests().into_iter().map(|file| file.name).collect(); assert_eq!( names, vec![ "console.mq.md", "csv.mq.md", "demo.mq.md", "format.mq.md", "fs.mq.md", "http.mq.md", "io.mq.md", "json.mq.md", "stream.mq.md", "table.mq.md", "text.mq.md", "utf8.mq.md", ], "a public stdlib module is missing a product test" ); } #[test] fn the_whole_bundled_library_runs_through_std_imports() { for file in product_tests() { let _guard = lock_fs(&file.name); let report = run_product_test(&file); assert_eq!(report["success"], true, "{}", file.name); assert_eq!( report["stdout"], file.stdout, "{} wrote unexpected stdout", file.name ); } } #[test] fn fs_test_exercises_the_file_operation_surface() { let _guard = lock_fs("fs.mq.md"); let report = run_product_test( product_tests() .iter() .find(|file| file.name == "fs.mq.md") .expect("fs test"), ); let items = report["value"]["items"].as_array().expect("list"); assert_eq!(items[0]["value"], true); assert_eq!(items[1]["decimal"], "7"); assert_eq!(items[2]["value"], true); assert_eq!(items[3]["value"], "file"); assert_eq!(items[4]["decimal"], "7"); assert_eq!(items[5]["items"][0]["value"], "fs-a.txt"); assert_eq!(items[6]["value"], true); assert_eq!(items[7]["value"], true); assert_eq!(items[8]["value"], true); assert_eq!(items[9]["value"], "你好\n"); assert_eq!(items[10]["value"], true); assert_eq!(items[11]["value"], true); assert!( !stdlib_dir().join("tests/out").exists(), "the fs test did not remove its directory" ); } #[test] fn json_test_parses_and_formats_nested_values() { let report = run_product_test( product_tests() .iter() .find(|file| file.name == "json.mq.md") .expect("json test"), ); let items = report["value"]["items"].as_array().expect("list"); assert_eq!(items[0]["value"], true); assert_eq!(items[1]["decimal"], "1"); assert_eq!(items[2]["value"], "说\"好"); assert_eq!( items[3]["value"], "[1, 2.5, -300.0, 0.4, {\"a\": 1.0}, \"x\"]" ); assert_eq!(items[4]["value"], false); assert_eq!(items[5]["value"], "json.invalid_array"); assert_eq!(items[6]["value"], "json.trailing"); } #[test] fn csv_test_parses_and_formats_quoted_rows() { let report = run_product_test( product_tests() .iter() .find(|file| file.name == "csv.mq.md") .expect("csv test"), ); let items = report["value"]["items"].as_array().expect("list"); let row = items[0]["items"].as_array().expect("row"); assert_eq!(row.len(), 3); assert_eq!(row[0]["value"], "甲"); assert_eq!(row[1]["value"], "乙,丙"); assert_eq!(row[2]["value"], "说\"好"); assert_eq!(items[1]["value"], "甲,\"乙,丙\",\"说\"\"好\""); let empty = items[2]["items"].as_array().expect("empty row"); assert_eq!(empty.len(), 1); assert_eq!(empty[0]["value"], ""); assert_eq!(items[3]["value"], "csv.unterminated_quote"); let quoted = items[4]["items"].as_array().expect("quoted row"); assert_eq!(quoted[0]["value"], "a"); assert_eq!(quoted[1]["value"], "b"); } #[test] fn format_test_pins_value_semantics_and_handle_observation() { let report = run_product_test( product_tests() .iter() .find(|file| file.name == "format.mq.md") .expect("format test"), ); let items = report["value"]["items"].as_array().expect("list"); assert_eq!(items[0]["decimal"], "3"); assert_eq!(items[1]["value"], "[\"文本\", 2, 1.5]"); assert_eq!(items[2]["value"], "{a: 1}"); assert_eq!(items[3]["value"], "[\"a\", 2]"); assert_eq!(items[4]["value"], "None"); } #[test] fn text_and_utf8_tests_agree_on_the_byte_encoding() { let text = run_product_test( product_tests() .iter() .find(|file| file.name == "text.mq.md") .expect("text test"), ); let utf8 = run_product_test( product_tests() .iter() .find(|file| file.name == "utf8.mq.md") .expect("utf8 test"), ); assert_eq!(text["value"]["items"][0]["decimal"], "2"); assert_eq!(text["value"]["items"][1]["decimal"], "195"); assert_eq!(text["value"]["items"][2]["decimal"], "169"); assert_eq!(utf8["value"]["items"][0]["decimal"], "2"); assert_eq!(utf8["value"]["items"][1]["value"], "é"); assert_eq!(utf8["value"]["items"][2]["value"], false); } #[test] fn stream_and_console_use_the_resource_endpoints() { let stream = run_product_test( product_tests() .iter() .find(|file| file.name == "stream.mq.md") .expect("stream test"), ); assert_eq!(stream["value"]["items"][0]["value"], true); assert_eq!(stream["value"]["items"][1]["decimal"], "7"); let console = run_product_test( product_tests() .iter() .find(|file| file.name == "console.mq.md") .expect("console test"), ); assert_eq!(console["value"]["items"][0]["value"], true); assert_eq!(console["value"]["items"][1]["value"], "hello"); assert!( console["trace"] .as_array() .unwrap() .iter() .any(|event| event["op"] == "resource.read" || event["op"] == "resource.open"), "console test did not go through a resource endpoint" ); }