Files
marqdo/tests/web_handbook.rs
T

354 lines
13 KiB
Rust

//! Execute the handbook itself, then serve the actual decomposition projects.
use serde_json::Value;
use std::{
fs,
io::{Read, Write},
net::{TcpListener, TcpStream},
path::{Path, PathBuf},
process::{Child, Command, Stdio},
thread,
time::{Duration, Instant},
};
fn root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
}
fn bin() -> &'static str {
env!("CARGO_BIN_EXE_marqdo")
}
struct Scratch(PathBuf);
impl Scratch {
fn new(label: &str) -> Self {
let p =
std::env::temp_dir().join(format!("mq-web-handbook-{label}-{}", std::process::id()));
fs::create_dir_all(&p).unwrap();
Self(p)
}
}
impl Drop for Scratch {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
fn command(session: &Path) -> Command {
let mut c = Command::new(bin());
c.current_dir(root())
.env("MARQDO_EXT", root().join("ext"))
.env("MARQDO_LIB", root().join("lib"))
.env(
"MARQDO_WEB_PLUGIN",
root()
.join("plugins/web/build")
.join(if cfg!(target_os = "macos") {
"libweb.dylib"
} else if cfg!(windows) {
"web.dll"
} else {
"libweb.so"
}),
)
.env("MARQDO_CALL_SESSION_DIR", session);
c
}
fn files(dir: &Path, out: &mut Vec<PathBuf>) {
for e in fs::read_dir(dir).unwrap() {
let p = e.unwrap().path();
if p.is_dir() {
files(&p, out)
} else if p.to_string_lossy().ends_with(".mq.md") {
out.push(p)
}
}
}
fn fences(src: &str, lang: &str) -> Vec<String> {
let mut out = Vec::new();
let mut current = None;
for l in src.lines() {
if l == format!("```{lang}") {
current = Some(String::new())
} else if l == "```" {
if let Some(b) = current.take() {
out.push(b)
}
} else if let Some(b) = current.as_mut() {
b.push_str(l);
b.push('\n')
}
}
assert!(current.is_none());
out
}
fn html_structure(html: &str) {
for marker in [
"mq-row",
"slot-footer",
"slot-footer-brand",
"slot-footer-links",
"slot-footer-links-docs",
"slot-footer-links-community",
] {
assert!(html.contains(marker), "missing {marker}: {html}")
}
assert!(!html.contains("map["), "nested nodes were stringified");
assert!(html.contains("<footer") && html.contains("<strong>"));
assert!(html.contains("viewport"));
}
#[test]
fn source_handbook_examples_and_contracts_on_both_backends() {
let scratch = Scratch::new("examples");
let mut paths = Vec::new();
files(&root().join("ext/web"), &mut paths);
paths.sort();
let mut calls = 0;
fn contracts(fs: &[marqdo::ast::Function], path: &Path) {
for f in fs {
let c = f
.contract
.as_ref()
.unwrap_or_else(|| panic!("{}: {} missing contract", path.display(), f.name));
assert!(c.returns.is_some());
assert_eq!(
c.params.len(),
f.params.len(),
"{}: {}",
path.display(),
f.name
);
contracts(&f.children, path)
}
}
for (i, p) in paths.iter().enumerate() {
let source = fs::read_to_string(p).unwrap();
let m = marqdo::load::load_module(p).unwrap();
contracts(&m.functions, p);
assert!(
marqdo::check::check_path(p).unwrap().is_empty(),
"{}",
p.display()
);
assert!(
marqdo::narrative_ratio::check_file(p).unwrap().is_empty(),
"{}",
p.display()
);
let blocks = fences(&source, "sh");
assert!(
!blocks.is_empty(),
"{} needs a runnable recipe",
p.display()
);
for backend in ["tree", "bytecode"] {
let session = scratch.0.join(format!("{i}-{backend}"));
fs::create_dir_all(&session).unwrap();
for block in &blocks {
for line in block.lines().filter(|l| !l.trim().is_empty()) {
assert!(line.starts_with("marqdo call "));
let invocation = line.replacen(
"marqdo call ",
&format!("\"{}\" call --backend {backend} ", bin()),
1,
);
let env = command(&session);
let out = Command::new("bash")
.args(["--noprofile", "--norc", "-ec", &invocation])
.current_dir(root())
.envs(env.get_envs().map(|(k, v)| (k, v.unwrap())))
.env_remove("BASH_ENV")
.output()
.unwrap();
assert!(
out.status.success(),
"{} [{backend}] {line}: {}\n{}",
p.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 line.contains(" inspect ") || line.contains(" 检视 ") {
let mut routes: Vec<_> = body["result"]["declared"]
.as_array()
.unwrap()
.iter()
.map(|v| v["path"].as_str().unwrap())
.collect();
routes.sort();
assert_eq!(routes, vec!["/", "/about", "/api/ping"]);
}
if line.contains("preview_nodes") || line.contains("预览节点") {
let h = body["result"].as_str().unwrap();
assert!(h.contains("mq-row") && h.contains("<h2"));
}
calls += 1;
}
}
for (j, block) in fences(&source, "marqdo").iter().enumerate() {
let file = scratch.0.join(format!("author-{i}-{j}.mq.md"));
fs::write(&file, block).unwrap();
let out = command(&session)
.args(["run", file.to_str().unwrap(), "--backend", backend])
.output()
.unwrap();
assert!(
out.status.success(),
"{}: {}",
p.display(),
String::from_utf8_lossy(&out.stderr)
);
let html = String::from_utf8(out.stdout).unwrap();
assert!(
html.contains("slot-footer")
&& html.contains("slot-brand")
&& html.contains("mq-row")
);
}
}
}
eprintln!("Executed {calls} commands directly from bilingual Web handbooks");
}
struct Server(Child);
impl Drop for Server {
fn drop(&mut self) {
let _ = self.0.kill();
let _ = self.0.wait();
}
}
fn get(port: u16, path: &str) -> std::io::Result<String> {
let mut stream = TcpStream::connect_timeout(
&format!("127.0.0.1:{port}").parse().unwrap(),
Duration::from_millis(300),
)?;
stream.set_read_timeout(Some(Duration::from_secs(2)))?;
write!(
stream,
"GET {path} HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n"
)?;
let mut body = String::new();
stream.read_to_string(&mut body)?;
Ok(body)
}
#[test]
fn decomposition_projects_preview_and_serve_the_same_structure() {
let scratch = Scratch::new("sites");
for zh in [false, true] {
for backend in ["tree", "bytecode"] {
let site = root().join(if zh {
"examples/web-layout-handbook-zh"
} else {
"examples/web-layout-handbook"
});
let mut source_files = Vec::new();
files(&site, &mut source_files);
for p in &source_files {
let text = fs::read_to_string(p).unwrap();
for forbidden in ["<div", "<style", "dom.raw", "json.set", "compose_"] {
assert!(
!text.contains(forbidden),
"{} uses {forbidden}",
p.display()
);
}
}
for leaf in [
"nav",
"main",
"footer/brand",
"footer/links/docs",
"footer/links/community",
] {
let content = site.join("components").join(leaf).join("content.md");
assert!(content.is_file());
let markdown = fs::read_to_string(content).unwrap();
assert!(
!regex::Regex::new(r"</?[A-Za-z][^>]*>")
.unwrap()
.is_match(&markdown),
"a terminal leaf contains HTML"
);
}
let out = command(&scratch.0)
.args([
"run",
site.join("preview.mq.md").to_str().unwrap(),
"--backend",
backend,
])
.output()
.unwrap();
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
let preview = String::from_utf8(out.stdout).unwrap();
html_structure(&preview);
let port = TcpListener::bind("127.0.0.1:0")
.unwrap()
.local_addr()
.unwrap()
.port();
let logpath = scratch.0.join(format!("server-{zh}-{backend}.log"));
let log = fs::File::create(&logpath).unwrap();
let mut server = Server(
command(&scratch.0)
.current_dir(&site)
.args([
"run",
"serve.mq.md",
"--backend",
backend,
"--bind",
&format!("{}={port}", if zh { "端口" } else { "port" }),
])
.stdout(Stdio::from(log.try_clone().unwrap()))
.stderr(Stdio::from(log))
.spawn()
.unwrap(),
);
let deadline = Instant::now() + Duration::from_secs(8);
let response = loop {
if let Ok(h) = get(port, "/") {
break h;
}
assert!(
server.0.try_wait().unwrap().is_none() && Instant::now() < deadline,
"server failed: {}",
fs::read_to_string(&logpath).unwrap()
);
thread::sleep(Duration::from_millis(40));
};
assert!(response.starts_with("HTTP/1.0 200") || response.starts_with("HTTP/1.1 200"));
let body = response.split_once("\r\n\r\n").unwrap().1;
html_structure(body);
assert_eq!(body.trim(), preview.trim(), "preview and live layout drift");
let about = get(port, "/about").unwrap();
assert!(about.contains("200 OK") && about.contains(if zh { "关于" } else { "About" }));
let ping = get(port, "/api/ping").unwrap();
assert!(ping.contains("200 OK"));
let value: Value =
serde_json::from_str(ping.split_once("\r\n\r\n").unwrap().1).unwrap();
assert!(value.to_string().contains("pong"));
}
}
}
#[test]
fn metadata_only_endpoint_has_the_same_result_on_both_backends() {
let source = "---\nmarkup: occlusion\ntype: endpoint\npath: /api/declaration\nmethod: POST\n---\n\nHandler declaration only.\n";
let mut results = Vec::new();
for backend in [marqdo::Backend::Tree, marqdo::Backend::Bytecode] {
let options = marqdo::RunOptions {
backend,
..Default::default()
};
let output = marqdo::run_source(source, &options).unwrap();
let json = marqdo::browser_session::value_as_json(&output.value).unwrap();
assert_eq!(json["ok"], true);
assert_eq!(json["value"]["kind"], "endpoint");
assert_eq!(json["value"]["path"], "/api/declaration");
assert_eq!(json["value"]["method"], "POST");
results.push(json);
assert!(marqdo::run_source("## helper\n\n*1*\n", &options).is_err());
}
assert_eq!(results[0], results[1]);
}