improvise/tests/web_demo_model.rs

//! The demo document the standalone page opens must be one a visitor can
//! *type into* (improvise-bck).
//!
//! The bug this guards against is not hypothetical: `examples/demo.improv`
//! leaves `Customer` and `Date` on the None axis, so every cell in it is an
//! aggregate over records the grid does not name, and an aggregate is not
//! settable — correct behaviour, and a demo where the first thing a visitor
//! clicks does nothing.
//!
//! The question is asked exactly the way the browser asks it. ADR 002 says a
//! cell is settable iff its `CellId` is `Record`, `project::cell_id` is the
//! one place that decides, and `render.rs::editable` in the wasm client is
//! that variant and nothing else (gotcha 42). So this test projects the
//! demo's whole grid through `grid_of` — the same function the server calls
//! per frame — and asserts on the surrogate, not on the axes. Asserting the
//! axes instead would re-derive the rule and could agree with itself while
//! disagreeing with the client.

use improvise::protocol::CellId;
use improvise_command::ui::app::App;
use improvise_command::ui::project::{Viewport, grid_of};

fn demo_app() -> App {
    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("web/demo.improv");
    let workbook = improvise::persistence::load(&path).expect("web/demo.improv loads");
    App::new(workbook, Some(path))
}

/// Every cell the page paints names a stored record, so every cell is one the
/// visitor may click and change.
#[test]
fn every_visible_cell_in_the_web_demo_is_settable() {
    let app = demo_app();
    let (rows, cols) = (app.layout.row_count(), app.layout.col_count());
    assert!(rows > 0 && cols > 0, "the demo grid must not be empty");

    let grid = grid_of(
        &app,
        Viewport {
            row_offset: 0,
            col_offset: 0,
            rows,
            cols,
        },
    );

    for r in 0..rows {
        for c in 0..cols {
            let cell = grid.cell(r, c).expect("a projected cell at every position");
            match &cell.id {
                Some(CellId::Record(_)) => {}
                other => panic!(
                    "cell ({r},{c}) — row {:?}, column {:?} — is {other:?}, not a Record, so the \
                     page will show it as un-editable",
                    grid.row_labels.get(r),
                    grid.col_labels.get(c),
                ),
            }
        }
    }
}

/// The demo is legible only if its headers are single-level. `GridCache`
/// slash-joins a multi-level tuple into one label (gotcha 44), so a second
/// category on an axis reads as `Espresso/North` in the browser. That is a
/// known gap in the shared layer; the demo must not stand on it.
#[test]
fn the_web_demo_has_one_category_per_visible_axis() {
    let app = demo_app();
    let (rows, cols) = (app.layout.row_count(), app.layout.col_count());
    let grid = grid_of(
        &app,
        Viewport {
            row_offset: 0,
            col_offset: 0,
            rows,
            cols,
        },
    );
    for label in grid.row_labels.iter().chain(grid.col_labels.iter()) {
        assert!(
            !label.contains('/'),
            "{label:?} is a joined multi-level label; the browser cannot draw header levels yet"
        );
    }
}

/// The payoff a visitor should see without pressing a key: a formula column
/// beside the two columns that feed it, so an edit visibly moves it.
#[test]
fn the_web_demo_shows_a_formula_beside_its_inputs() {
    let app = demo_app();
    let grid = grid_of(
        &app,
        Viewport {
            row_offset: 0,
            col_offset: 0,
            rows: app.layout.row_count(),
            cols: app.layout.col_count(),
        },
    );
    assert_eq!(grid.col_labels, vec!["Revenue", "Cost", "Profit"]);
    assert_eq!(
        grid.row_labels,
        vec!["Espresso", "Latte", "Cold Brew", "Pastry"]
    );
    let profit = grid.cell(0, 2).expect("the Profit cell");
    assert_eq!(profit.text, "12,200", "18,400 - 6,200, recomputed on load");
}