improvise/crates/improvise-incremental/tests/oracle.rs

//! `Eager` against the evaluator, and the harness against wrong backends.
//! Evidence: `context/test-evidence/improvise-incremental.md`.

use improvise_core::formula::ast::AggFunc;
use improvise_core::formula::parse_formula;
use improvise_core::model::cell::{CellKey, CellValue};
use improvise_core::model::{Aggregation, Model};
use improvise_core::view::Axis;
use improvise_incremental::{
    Derived, Divergence, Eager, Edit, Maintained, Probe, differential, probes, same_value,
};
use proptest::prelude::*;
use std::path::Path;

fn key(region: &str, product: &str, measure: &str) -> CellKey {
    CellKey::new(vec![
        ("Region".into(), region.into()),
        ("Product".into(), product.into()),
        ("_Measure".into(), measure.into()),
    ])
}

fn partial(product: &str, measure: &str) -> CellKey {
    CellKey::new(vec![
        ("Product".into(), product.into()),
        ("_Measure".into(), measure.into()),
    ])
}

fn num(n: f64) -> Option<CellValue> {
    Some(CellValue::Number(n))
}

fn text(s: &str) -> Option<CellValue> {
    Some(CellValue::Text(s.into()))
}

fn mixed() -> Option<CellValue> {
    Some(CellValue::Error("mixed".into()))
}

/// Region is the None category. Revenue and Cost are numbers; Note is text,
/// unanimous under A and conflicting under B.
fn hand_model() -> Model {
    let mut m = Model::new("hand");
    for (cat, items) in [("Region", ["East", "West"]), ("Product", ["A", "B"])] {
        m.add_category(cat).unwrap();
        for item in items {
            m.category_mut(cat).unwrap().add_item(item);
        }
    }
    for measure in ["Revenue", "Cost", "Note"] {
        m.category_mut("_Measure").unwrap().add_item(measure);
    }
    let rows = [
        ("East", "A", 10.0, 4.0, "n", "n"),
        ("West", "A", 5.0, 2.0, "n", "n"),
        ("East", "B", 7.0, 3.0, "x", "x"),
        ("West", "B", 1.0, 1.0, "y", "y"),
    ];
    for (r, p, rev, cost, note, _) in rows {
        m.set_cell(key(r, p, "Revenue"), CellValue::Number(rev));
        m.set_cell(key(r, p, "Cost"), CellValue::Number(cost));
        m.set_cell(key(r, p, "Note"), CellValue::Text(note.into()));
    }
    m.add_formula(parse_formula("Profit = Revenue - Cost", "_Measure").unwrap());
    m
}

fn hand_eager() -> Eager {
    Eager::new(hand_model(), vec!["Region".into()])
}

fn hand_edits() -> Vec<Edit> {
    vec![
        Edit::SetCell(key("East", "A", "Revenue"), CellValue::Number(20.0)),
        Edit::SetMeasureAgg {
            measure: "Revenue".into(),
            func: AggFunc::Max,
        },
        Edit::ClearCell(key("West", "A", "Revenue")),
        Edit::SetCell(key("West", "B", "Revenue"), CellValue::Text("oops".into())),
        Edit::AddFormula(parse_formula("Double = Revenue * 2", "_Measure").unwrap()),
        Edit::RemoveFormula {
            target: "Profit".into(),
            target_category: "_Measure".into(),
        },
    ]
}

#[test]
fn eager_raw_fold_sums_by_default() {
    assert_eq!(hand_eager().raw_fold(&partial("A", "Revenue")), num(15.0));
}

#[test]
fn eager_raw_fold_follows_the_measures_aggregation() {
    let mut eager = hand_eager();
    eager.apply(&Edit::SetMeasureAgg {
        measure: "Revenue".into(),
        func: AggFunc::Max,
    });
    assert_eq!(eager.raw_fold(&partial("A", "Revenue")), num(10.0));
    assert_eq!(eager.raw_fold(&partial("A", "Cost")), num(6.0));
}

#[test]
fn eager_raw_fold_of_text_is_unanimous_or_mixed() {
    let eager = hand_eager();
    assert_eq!(eager.raw_fold(&partial("A", "Note")), text("n"));
    assert_eq!(eager.raw_fold(&partial("B", "Note")), mixed());
}

#[test]
fn eager_value_reads_a_formula_exactly_and_folded() {
    let eager = hand_eager();
    assert_eq!(
        eager.value(&key("East", "A", "Profit"), Aggregation::Exact),
        num(6.0)
    );
    assert_eq!(
        eager.value(&partial("A", "Profit"), Aggregation::OverHidden),
        num(9.0)
    );
}

#[test]
fn eager_follows_an_edit_to_the_cell_a_fold_reads() {
    let mut eager = hand_eager();
    eager.apply(&Edit::SetCell(
        key("East", "A", "Revenue"),
        CellValue::Number(20.0),
    ));
    assert_eq!(eager.raw_fold(&partial("A", "Revenue")), num(25.0));
    assert_eq!(
        eager.value(&partial("A", "Profit"), Aggregation::OverHidden),
        num(19.0)
    );
}

#[test]
fn eager_numbers_among_text_are_mixed() {
    let mut eager = hand_eager();
    eager.apply(&Edit::SetCell(
        key("West", "B", "Revenue"),
        CellValue::Text("oops".into()),
    ));
    assert_eq!(eager.raw_fold(&partial("B", "Revenue")), mixed());
}

fn corpus() -> Vec<(String, Model, Vec<String>)> {
    let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
    let mut out = Vec::new();
    for file in ["examples/demo.improv", "web/demo.improv"] {
        let wb = improvise_io::persistence::load(&root.join(file)).unwrap();
        let mut seen: Vec<Vec<String>> = Vec::new();
        for (name, view) in &wb.views {
            let none: Vec<String> = view
                .categories_on(Axis::None)
                .into_iter()
                .map(String::from)
                .collect();
            if !seen.contains(&none) {
                seen.push(none.clone());
                out.push((format!("{file}:{name}"), wb.model.clone(), none));
            }
        }
    }
    out.push(("hand".into(), hand_model(), vec!["Region".into()]));
    out
}

/// Edits built from the model's own first cell: overwrite, text, clear, a new
/// record, a new aggregation, and the first formula removed then restored.
fn edits_for(model: &Model) -> Vec<Edit> {
    let Some((first, _)) = model.data.iter_cells().next() else {
        return vec![];
    };
    let (last_cat, _) = first.0.last().unwrap().clone();
    let measure = first.get("_Measure").map(String::from);
    let fresh = first.clone().with(last_cat, "Zz-new");
    let mut edits = vec![
        Edit::SetCell(first.clone(), CellValue::Number(7.5)),
        Edit::SetCell(first.clone(), CellValue::Text("t".into())),
        Edit::SetCell(fresh.clone(), CellValue::Number(3.0)),
        Edit::ClearCell(first),
    ];
    edits.extend(measure.map(|m| Edit::SetMeasureAgg {
        measure: m,
        func: AggFunc::Max,
    }));
    if let Some(f) = model.formulas().first() {
        edits.push(Edit::RemoveFormula {
            target: f.target.clone(),
            target_category: f.target_category.clone(),
        });
        edits.push(Edit::AddFormula(f.clone()));
    }
    edits.push(Edit::ClearCell(fresh));
    edits
}

#[test]
fn eager_matches_the_evaluator_on_the_shipped_documents() {
    for (name, model, none) in corpus() {
        let eager = Eager::new(model.clone(), none.clone());
        let mut direct = model.clone();
        direct.recompute_formulas(&none);
        let asked = probes(eager.model());
        assert!(!asked.is_empty(), "{name}: no probes");
        for probe in asked {
            let want = match &probe {
                Probe::Value(k, a) => direct.evaluate_aggregated(k, *a),
                Probe::RawFold(k) if direct.formula_for(k).is_some() => None,
                Probe::RawFold(k) => direct.evaluate_aggregated(k, Aggregation::OverHidden),
            };
            assert_eq!(probe.ask(&eager), want, "{name}: {probe:?}");
        }
    }
}

#[test]
fn eager_agrees_with_itself_over_every_corpus_edit_sequence() {
    let mut files_done: Vec<String> = Vec::new();
    for (name, model, none) in corpus() {
        let file = name.split(':').next().unwrap().to_string();
        if files_done.contains(&file) {
            continue;
        }
        files_done.push(file);
        let mut edits = edits_for(&model);
        // Probes grow with the cells squared-ish, and a debug build pays for it.
        if model.data.iter_cells().count() > 40 {
            edits.truncate(4);
        }
        let report = differential(
            &model,
            &none,
            Eager::new(model.clone(), none.clone()),
            &edits,
        )
        .unwrap_or_else(|d| panic!("{name}: {d}"));
        assert_eq!(report.steps, edits.len() + 1, "{name}");
        assert!(report.probes > 0, "{name}");
    }
}

fn grouped_model() -> Model {
    let mut m = Model::new("grouped");
    m.add_category("Region").unwrap();
    m.add_category("Product").unwrap();
    m.category_mut("Region")
        .unwrap()
        .add_group(improvise_core::model::category::Group::new("Coastal"));
    let region = m.category_mut("Region").unwrap();
    region.add_item_in_group("East", "Coastal");
    region.add_item_in_group("West", "Coastal");
    region.add_item("Inland");
    m.category_mut("Product").unwrap().add_item("A");
    m.category_mut("_Measure").unwrap().add_item("Revenue");
    for (r, v) in [("East", 10.0), ("West", 5.0), ("Inland", 2.0)] {
        m.set_cell(key(r, "A", "Revenue"), CellValue::Number(v));
    }
    m
}

fn coastal() -> CellKey {
    key("Coastal", "A", "Revenue")
}

/// A wrong backend: an `Eager` told every edit, answering one thing wrongly.
#[derive(Clone, Copy)]
enum Fault {
    IgnoresAggregation,
    IgnoresMeasureAggregation,
    GoesStaleAfterTwoEdits,
    IgnoresClear,
    WrongFoldedFormula,
    IgnoresRemoveFormula,
    WrongWhenTwoAreDropped,
    RawFoldReturnsFormula,
    WrongOnAGroup,
}

struct Rival {
    inner: Eager,
    fault: Fault,
    seen: usize,
}

impl Rival {
    fn over(inner: Eager, fault: Fault) -> Self {
        Rival {
            inner,
            fault,
            seen: 0,
        }
    }

    fn of(fault: Fault) -> Self {
        Self::over(hand_eager(), fault)
    }
}

impl Derived for Rival {
    fn value(&self, k: &CellKey, agg: Aggregation) -> Option<CellValue> {
        let wrong = match self.fault {
            Fault::WrongFoldedFormula => {
                *k == partial("A", "Profit") && agg == Aggregation::OverHidden
            }
            Fault::WrongWhenTwoAreDropped => *k == only_revenue(),
            Fault::WrongOnAGroup => *k == coastal() && agg == Aggregation::Exact,
            _ => false,
        };
        match (wrong, self.fault) {
            (true, _) => num(-999.0),
            (_, Fault::IgnoresAggregation) => self.inner.value(k, Aggregation::Exact),
            _ => self.inner.value(k, agg),
        }
    }

    fn raw_fold(&self, p: &CellKey) -> Option<CellValue> {
        match self.fault {
            Fault::WrongWhenTwoAreDropped if *p == only_revenue() => num(-999.0),
            Fault::RawFoldReturnsFormula => self.inner.value(p, Aggregation::OverHidden),
            _ => self.inner.raw_fold(p),
        }
    }
}

impl Maintained for Rival {
    fn apply(&mut self, edit: &Edit) {
        self.seen += 1;
        let skip = match (self.fault, edit) {
            (Fault::IgnoresMeasureAggregation, Edit::SetMeasureAgg { .. }) => true,
            (Fault::GoesStaleAfterTwoEdits, _) => self.seen > 2,
            (Fault::IgnoresClear, Edit::ClearCell(_)) => true,
            (Fault::IgnoresRemoveFormula, Edit::RemoveFormula { .. }) => true,
            _ => false,
        };
        if !skip {
            self.inner.apply(edit);
        }
    }
}

fn only_revenue() -> CellKey {
    CellKey::new(vec![("_Measure".into(), "Revenue".into())])
}

fn measure_of(probe: &Probe) -> Option<&str> {
    match probe {
        Probe::Value(k, _) | Probe::RawFold(k) => k.get("_Measure"),
    }
}

fn run_rival(fault: Fault) -> Result<improvise_incremental::Report, Divergence> {
    differential(
        &hand_model(),
        &["Region".to_string()],
        Rival::of(fault),
        &hand_edits(),
    )
}

#[test]
fn the_harness_passes_a_backend_that_is_right() {
    let report = differential(
        &hand_model(),
        &["Region".to_string()],
        hand_eager(),
        &hand_edits(),
    )
    .unwrap();
    assert_eq!(report.steps, hand_edits().len() + 1);
}

#[test]
fn the_harness_catches_a_backend_that_ignores_the_aggregation() {
    let d = run_rival(Fault::IgnoresAggregation).unwrap_err();
    assert_eq!(d.step, 0);
    assert_eq!(
        d.probe,
        Probe::Value(key("East", "A", "Profit"), Aggregation::OverHidden)
    );
    assert_eq!((d.eager, d.candidate), (None, num(6.0)));
}

#[test]
fn the_harness_catches_a_backend_that_ignores_the_measure_aggregation() {
    let d = run_rival(Fault::IgnoresMeasureAggregation).unwrap_err();
    assert_eq!(d.step, 2, "{d}");
    assert_eq!(measure_of(&d.probe), Some("Revenue"), "{d}");
}

#[test]
fn the_harness_catches_a_backend_that_goes_stale_after_two_edits() {
    let d = run_rival(Fault::GoesStaleAfterTwoEdits).unwrap_err();
    assert_eq!(d.step, 3, "{d}");
    assert_eq!(measure_of(&d.probe), Some("Revenue"), "{d}");
}

#[test]
fn the_harness_catches_a_backend_that_ignores_a_clear() {
    let d = run_rival(Fault::IgnoresClear).unwrap_err();
    assert_eq!(d.step, 3, "{d}");
    assert_eq!(measure_of(&d.probe), Some("Revenue"), "{d}");
    assert!(d.to_string().starts_with("divergence at step 3:"), "{d}");
}

#[test]
fn the_harness_catches_a_wrong_folded_formula_value() {
    let d = run_rival(Fault::WrongFoldedFormula).unwrap_err();
    assert_eq!(d.step, 0);
    assert_eq!(
        d.probe,
        Probe::Value(partial("A", "Profit"), Aggregation::OverHidden)
    );
    assert_eq!((d.eager, d.candidate), (num(9.0), num(-999.0)));
}

#[test]
fn the_harness_catches_a_backend_that_keeps_answering_for_a_removed_formula() {
    let d = run_rival(Fault::IgnoresRemoveFormula).unwrap_err();
    assert_eq!(d.step, hand_edits().len(), "{d}");
    assert_eq!(measure_of(&d.probe), Some("Profit"), "{d}");
    assert!(d.eager.is_none() && d.candidate.is_some(), "{d}");
}

#[test]
fn the_harness_catches_a_fault_that_only_shows_after_two_coordinates_are_dropped() {
    let d = run_rival(Fault::WrongWhenTwoAreDropped).unwrap_err();
    assert_eq!(d.step, 0);
    assert_eq!(d.probe, Probe::Value(only_revenue(), Aggregation::Exact));
    assert_eq!(d.candidate, num(-999.0));
}

#[test]
fn the_harness_catches_a_raw_fold_that_returns_a_formula() {
    let d = run_rival(Fault::RawFoldReturnsFormula).unwrap_err();
    assert_eq!(d.step, 0);
    assert!(matches!(d.probe, Probe::RawFold(_)), "{d}");
    assert_eq!(measure_of(&d.probe), Some("Profit"), "{d}");
    assert!(d.eager.is_none() && d.candidate.is_some(), "{d}");
}

#[test]
fn the_harness_catches_a_wrong_group_fold() {
    let eager = Eager::new(grouped_model(), vec![]);
    let d = differential(
        &grouped_model(),
        &[],
        Rival::over(eager, Fault::WrongOnAGroup),
        &[],
    )
    .unwrap_err();
    assert_eq!(d.probe, Probe::Value(coastal(), Aggregation::Exact));
    assert_eq!((d.eager, d.candidate), (num(15.0), num(-999.0)));
}

#[test]
fn eager_folds_a_group_it_is_asked_about() {
    let eager = Eager::new(grouped_model(), vec![]);
    assert_eq!(eager.value(&coastal(), Aggregation::Exact), num(15.0));
}

#[test]
fn eager_raw_fold_is_never_a_formula() {
    let eager = hand_eager();
    assert_eq!(
        eager.value(&partial("A", "Profit"), Aggregation::OverHidden),
        num(9.0)
    );
    assert_eq!(eager.raw_fold(&partial("A", "Profit")), None);
}

#[test]
fn eager_add_and_remove_formula_change_what_a_key_reads() {
    let mut eager = hand_eager();
    let k = key("East", "A", "Double");
    assert_eq!(eager.value(&k, Aggregation::Exact), None);
    eager.apply(&Edit::AddFormula(
        parse_formula("Double = Revenue * 2", "_Measure").unwrap(),
    ));
    assert_eq!(eager.value(&k, Aggregation::Exact), num(20.0));
    eager.apply(&Edit::RemoveFormula {
        target: "Double".into(),
        target_category: "_Measure".into(),
    });
    assert_eq!(eager.value(&k, Aggregation::Exact), None);
}

#[test]
fn eager_clear_cell_leaves_the_key_absent() {
    let mut eager = hand_eager();
    let k = key("East", "A", "Revenue");
    eager.apply(&Edit::ClearCell(k.clone()));
    assert_eq!(eager.value(&k, Aggregation::Exact), None);
    assert_eq!(eager.model().get_cell(&k), None);
}

#[test]
fn same_value_follows_the_float_rules_and_is_exact_elsewhere() {
    let n = |x: f64| num(x);
    assert!(same_value(&n(f64::NAN), &n(f64::NAN)));
    assert!(same_value(&n(-0.0), &n(0.0)));
    assert!(!same_value(&n(1.0), &n(1.000_000_000_000_000_2)));
    assert!(!same_value(&n(1.0), &n(f64::NAN)));
    assert!(same_value(&text("a"), &text("a")));
    assert!(!same_value(&text("a"), &text("b")));
    let err = |s: &str| Some(CellValue::Error(s.into()));
    assert!(same_value(&err("mixed"), &err("mixed")));
    assert!(!same_value(&err("mixed"), &err("circular")));
    assert!(!same_value(&None, &n(0.0)));
    assert!(same_value(&None, &None));
}

#[test]
fn probes_cover_folds_formulas_measures_and_groups() {
    let hand = probes(&hand_model());
    let has = |p: Probe| hand.contains(&p);
    assert!(has(Probe::RawFold(partial("A", "Revenue"))));
    assert!(has(Probe::Value(
        key("East", "A", "Revenue"),
        Aggregation::Exact
    )));
    assert!(has(Probe::Value(
        partial("A", "Profit"),
        Aggregation::Exact
    )));
    assert!(has(Probe::Value(
        partial("A", "Profit"),
        Aggregation::OverHidden
    )));
    assert!(has(Probe::Value(only_revenue(), Aggregation::OverHidden)));
    assert!(has(Probe::RawFold(CellKey::new(vec![]))));
    let grouped = probes(&grouped_model());
    assert!(grouped.contains(&Probe::Value(coastal(), Aggregation::Exact)));
}

#[test]
fn an_edit_names_its_key_as_two_value_probes_and_a_fold() {
    let k = key("East", "A", "Revenue");
    let asked = improvise_incremental::edit_probes(&Edit::ClearCell(k.clone()));
    assert!(asked.contains(&Probe::Value(k.clone(), Aggregation::Exact)));
    assert!(asked.contains(&Probe::Value(k.clone(), Aggregation::OverHidden)));
    assert!(asked.contains(&Probe::RawFold(k)));
    let none = improvise_incremental::edit_probes(&Edit::SetMeasureAgg {
        measure: "Revenue".into(),
        func: AggFunc::Max,
    });
    assert!(none.is_empty());
}

/// An `Eager` rebuilt from scratch on every edit: maintaining one in place
/// must give the same answers as building it afresh.
struct Fresh {
    model: Model,
    none: Vec<String>,
    eager: Eager,
}

impl Derived for Fresh {
    fn value(&self, k: &CellKey, agg: Aggregation) -> Option<CellValue> {
        self.eager.value(k, agg)
    }

    fn raw_fold(&self, p: &CellKey) -> Option<CellValue> {
        self.eager.raw_fold(p)
    }
}

impl Maintained for Fresh {
    fn apply(&mut self, edit: &Edit) {
        edit.apply(&mut self.model);
        self.eager = Eager::new(self.model.clone(), self.none.clone());
    }
}

fn any_key() -> impl Strategy<Value = CellKey> {
    (
        prop::sample::select(vec!["East", "West"]),
        prop::sample::select(vec!["A", "B"]),
        prop::sample::select(vec!["Revenue", "Cost", "Note"]),
    )
        .prop_map(|(r, p, m)| key(r, p, m))
}

fn any_value() -> impl Strategy<Value = CellValue> {
    prop_oneof![
        (-4i32..5).prop_map(|n| CellValue::Number(f64::from(n))),
        Just(CellValue::Number(-0.0)),
        prop::sample::select(vec!["n", "x"]).prop_map(|t| CellValue::Text(t.into())),
    ]
}

fn any_edit() -> impl Strategy<Value = Edit> {
    prop_oneof![
        (any_key(), any_value()).prop_map(|(k, v)| Edit::SetCell(k, v)),
        any_key().prop_map(Edit::ClearCell),
        prop::sample::select(vec!["Profit = Revenue - Cost", "Double = Revenue * 2"])
            .prop_map(|raw| Edit::AddFormula(parse_formula(raw, "_Measure").unwrap())),
        prop::sample::select(vec!["Profit", "Double"]).prop_map(|t| Edit::RemoveFormula {
            target: t.into(),
            target_category: "_Measure".into(),
        }),
        (
            prop::sample::select(vec!["Revenue", "Cost"]),
            prop::sample::select(vec![AggFunc::Sum, AggFunc::Max, AggFunc::Min, AggFunc::Avg]),
        )
            .prop_map(|(m, func)| Edit::SetMeasureAgg {
                measure: m.into(),
                func,
            }),
    ]
}

proptest! {
    #[test]
    fn a_maintained_eager_equals_a_fresh_one_over_random_edit_sequences(
        edits in prop::collection::vec(any_edit(), 0..4)
    ) {
        let model = hand_model();
        let none = vec!["Region".to_string()];
        let fresh = Fresh {
            model: model.clone(),
            none: none.clone(),
            eager: Eager::new(model.clone(), none.clone()),
        };
        let run = differential(&model, &none, fresh, &edits);
        prop_assert!(run.is_ok(), "{}", run.unwrap_err());
    }
}