use std::fs;
use std::io::{Read, Write};
use std::net::TcpListener;
use std::path::Path;
use std::process::{Command, Output};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use std::time::Duration;
fn coatcheck(root: &Path) -> Command {
let mut command = Command::new(env!("CARGO_BIN_EXE_coatcheck"));
command.args(["--project-root", root.to_str().unwrap()]);
command
}
fn run(mut command: Command) -> Output {
command.output().unwrap()
}
#[test]
fn init_scaffolds_a_rerunnable_project_boundary() {
let project = tempfile::tempdir().unwrap();
let mut first = coatcheck(project.path());
first.args(["init", "--package-manager", "bun", "--skip-install"]);
let first = run(first);
assert!(
first.status.success(),
"{}",
String::from_utf8_lossy(&first.stderr)
);
let config = fs::read_to_string(project.path().join("Coatcheck.toml")).unwrap();
assert!(config.contains("version = 1"));
assert!(config.contains("name = "));
let parsed: coatcheck::config::Config = toml::from_str(&config).unwrap();
assert!(!parsed.name.is_empty());
assert!(project.path().join("package.json").is_file());
assert!(project.path().join("coatcheck/example.spec.ts").is_file());
assert!(
fs::read_to_string(project.path().join(".gitignore"))
.unwrap()
.contains(".coatcheck/")
);
let mut second = coatcheck(project.path());
second.args(["init", "--skip-install"]);
let second = run(second);
assert!(!second.status.success());
assert!(String::from_utf8_lossy(&second.stderr).contains("already exists"));
}
#[cfg(unix)]
#[test]
fn test_fetches_manifest_generates_cases_and_invokes_custom_specs() {
use std::os::unix::fs::PermissionsExt;
let project = tempfile::tempdir().unwrap();
let (url, stop, server) = fixture_server();
let config = format!(
r#"
version = 1
name = "Fixture"
[host]
command = ["true"]
url = "{url}"
health = "/health"
manifest = "/__coatcheck/manifest.json"
startup_timeout_seconds = 5
[test]
story_globs = ["coatcheck/**/*.spec.ts"]
artifacts = ".coatcheck/artifacts"
timeout_ms = 30000
axe_impacts = ["serious", "critical"]
"#
);
fs::write(project.path().join("Coatcheck.toml"), config).unwrap();
let fake_bin = project.path().join("fake-bin");
fs::create_dir_all(&fake_bin).unwrap();
for name in ["bun", "bunx"] {
let path = fake_bin.join(name);
fs::write(
&path,
if name == "bunx" {
"#!/bin/sh\nprintf '%s\\n' \"$*\" > \"$COATCHECK_FAKE_BUNX_MARKER\"\n"
} else {
"#!/bin/sh\nexit 0\n"
},
)
.unwrap();
let mut permissions = fs::metadata(&path).unwrap().permissions();
permissions.set_mode(0o755);
fs::set_permissions(path, permissions).unwrap();
}
let marker = project.path().join("bunx-invocation.txt");
let path = format!("{}:{}", fake_bin.display(), std::env::var("PATH").unwrap());
let mut command = coatcheck(project.path());
command
.args(["test", "--no-host"])
.env("PATH", path)
.env("COATCHECK_FAKE_BUNX_MARKER", &marker);
let output = run(command);
stop.store(true, Ordering::Relaxed);
server.join().unwrap();
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
let generated =
fs::read_to_string(project.path().join(".coatcheck/generated/manifest.spec.ts")).unwrap();
let playwright = fs::read_to_string(
project
.path()
.join(".coatcheck/generated/playwright.config.ts"),
)
.unwrap();
let review = fs::read_to_string(project.path().join(".coatcheck/artifacts/review.md")).unwrap();
assert!(generated.contains("Button [mobile]"));
assert!(generated.contains("button--mobile"));
assert!(playwright.contains("coatcheck/**/*.spec.ts"));
assert!(
fs::read_to_string(marker)
.unwrap()
.contains("playwright test --config")
);
assert!(review.contains("Semantic result: **passed**"));
assert!(review.contains("PNG files are review artifacts only"));
}
fn fixture_server() -> (String, Arc<AtomicBool>, thread::JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let address = listener.local_addr().unwrap();
let stop = Arc::new(AtomicBool::new(false));
let thread_stop = Arc::clone(&stop);
let server = thread::spawn(move || {
while !thread_stop.load(Ordering::Relaxed) {
match listener.accept() {
Ok((mut stream, _)) => {
let mut request = [0_u8; 4096];
let read = stream.read(&mut request).unwrap_or_default();
let request = String::from_utf8_lossy(&request[..read]);
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.unwrap_or("/");
let body = match path {
"/health" => "ok".to_owned(),
"/__coatcheck/manifest.json" => manifest_json(),
_ => "not found".to_owned(),
};
let status = if path == "/health" || path == "/__coatcheck/manifest.json" {
"200 OK"
} else {
"404 Not Found"
};
let response = format!(
"HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes());
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
thread::sleep(Duration::from_millis(10));
}
Err(error) => panic!("fixture server failed: {error}"),
}
}
});
(format!("http://{address}"), stop, server)
}
fn manifest_json() -> String {
serde_json::json!({
"version": 1,
"name": "Fixture",
"frame": {
"version": 1,
"path": "/__coatcheck/frame",
"story_query": "story",
"scene_query": "scene",
"root_selector": "[data-coatcheck-frame]",
"ready_selector": "[data-coatcheck-ready]",
"error_selector": "[data-coatcheck-error]"
},
"scenes": [{
"id": "mobile",
"label": "Mobile",
"viewport": { "width": 393, "height": 852 },
"surface": "canvas"
}],
"stories": [{
"id": "button",
"title": "Button",
"tier": "Atoms",
"kind": "playground",
"description": "Primary action",
"source": "src/button.rs",
"args": [],
"scenes": ["mobile"]
}]
})
.to_string()
}