Skip to content

The design language that makes your AI harness better at design.

JavaScript
3.8 KB
Raw Blame
//! `straggler` and `unbalanced-heading` against an installed browser, on the
//! fixtures' should-flag and should-pass cases. Skips cleanly when there is
//! none.
//!
//! Both rules read the rendered line boxes, which the static engine never
//! measures. The fixtures set their copy in a monospace face on columns sized
//! in `ch`, so the breaks are the same on every machine.

#[path = "support/http.rs"]
mod http;

use std::collections::HashMap;
use std::path::{Path, PathBuf};

use impeccable_browser::BrowserEngine;
use impeccable_detect::engines::{ScanOptions, UrlEngine};

fn fixtures_dir() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/antipatterns")
}

fn engine() -> Option<BrowserEngine> {
    let env: HashMap<String, String> = std::env::vars().collect();
    if impeccable_browser::discovery::find_browser(&env).is_err() {
        eprintln!("skip: no installed browser found");
        return None;
    }
    Some(BrowserEngine::new(env))
}

/// `(rule, snippet, selector, severity)` for each line-break finding on one
/// fixture.
fn findings(engine: &BrowserEngine, origin: &str, fixture: &str) -> Vec<(String, String, String, String)> {
    engine
        .detect_url(&format!("{origin}/{fixture}"), &ScanOptions::default())
        .expect("scan")
        .into_iter()
        .filter(|f| f.antipattern == "straggler" || f.antipattern == "unbalanced-heading")
        .map(|f| {
            let selector = f.extras.get("selector").and_then(|s| s.as_str()).unwrap_or("").to_string();
            (f.antipattern, f.snippet, selector, f.severity)
        })
        .collect()
}

fn assert_cases(found: &[(String, String, String, String)], rule: &str, flag: &[&str], pass: &[&str]) {
    for case in flag {
        assert!(
            found.iter().any(|(id, _, sel, _)| id == rule && sel.contains(case)),
            "{rule}: `{case}` should flag, got {found:?}"
        );
    }
    for case in pass {
        assert!(
            !found.iter().any(|(_, _, sel, _)| sel.contains(case)),
            "{rule}: `{case}` should pass, got {found:?}"
        );
    }
    assert!(found.iter().all(|(id, _, _, _)| id == rule), "{found:?}");
    // An uneven break can be the design, so neither rule counts as a failure.
    assert!(found.iter().all(|(_, _, _, sev)| sev == "advisory"), "{found:?}");
}

#[test]
fn the_line_break_rules_read_the_rendered_lines() {
    let Some(engine) = engine() else { return };
    let origin = http::serve(|path| {
        std::fs::read(fixtures_dir().join(path.trim_start_matches('/')))
            .ok()
            .map(|body| ("text/html; charset=utf-8", body))
    });

    let stragglers = findings(&engine, &origin, "straggler.html");
    assert_cases(
        &stragglers,
        "straggler",
        &[
            "flag-paragraph",
            "flag-list-item",
            "flag-quote",
            "flag-caption",
            "flag-inline",
            "flag-centered",
            "flag-right",
        ],
        &[
            "pass-pretty",
            "pass-balance",
            "pass-two-words",
            "pass-long-word",
            "pass-narrow",
            "pass-break",
            "pass-inline-icon",
            "pass-narrow-letters",
            "pass-one-line",
        ],
    );
    let paragraph = stragglers.iter().find(|(_, _, sel, _)| sel.contains("flag-paragraph")).unwrap();
    assert!(paragraph.1.starts_with("\"text.\" alone on the last of 4 lines"), "{paragraph:?}");

    let headings = findings(&engine, &origin, "unbalanced-heading.html");
    assert_cases(
        &headings,
        "unbalanced-heading",
        &["flag-hero", "flag-three-lines", "flag-centred", "flag-card", "flag-pretty-ancestor"],
        &["pass-balance", "pass-pretty-ancestor", "pass-one-line", "pass-even", "pass-stacked", "pass-statement", "pass-two-words", "pass-narrow", "pass-break"],
    );
}