coatcheck 0.2.1

Contracts and a Playwright accessibility runner for Topcoat component workbenches.
Documentation
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()
}