wanderbooks/crates/ledger-gui/tests/screens.rs

//! Screenshots of every screen, for eyes. Set `SHOT_BOOKS` to a books dir
//! (containing `books-data/`, its settings in its journal) and `SHOT_DIR` to
//! where the PNGs go; without them this test does nothing. `SHOT_REGISTER=all`
//! shows an account's register on every date instead of its default.

use egui_kittest::Harness;
use ledger_gui::nav::{ReportKind, Route};
use ledger_gui::{App, Source, data};
use std::path::PathBuf;

/// A test's dir, removed when the test ends, pass or panic.
struct TestDir(PathBuf);

impl Drop for TestDir {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.0);
    }
}

#[test]
fn screenshots() {
    let Ok(out) = std::env::var("SHOT_DIR") else {
        return;
    };
    let fixed_today: Option<chrono::NaiveDate> = std::env::var("SHOT_TODAY")
        .ok()
        .and_then(|d| d.parse().ok());
    // Demo books (no SHOT_BOOKS) go when the run ends, pass or panic.
    let mut _demo = None;
    let books = match std::env::var("SHOT_BOOKS") {
        Ok(b) => PathBuf::from(b),
        Err(_) => {
            let d = fixed_today
                .unwrap_or_else(|| chrono::NaiveDate::from_ymd_opt(2026, 10, 12).unwrap());
            let dir =
                std::env::temp_dir().join(format!("ledger-gui-shots-demo-{}", std::process::id()));
            let _ = std::fs::remove_dir_all(&dir);
            _demo = Some(TestDir(dir.clone()));
            ledger_gui::demo::build(&dir, d).unwrap();
            dir
        }
    };
    let out = PathBuf::from(out);
    std::fs::create_dir_all(&out).unwrap();
    let source = Source {
        data_dir: books.join("books-data"),
        today: fixed_today.or_else(|| {
            std::env::var("SHOT_BOOKS")
                .is_err()
                .then(|| chrono::NaiveDate::from_ymd_opt(2026, 10, 12).unwrap())
        }),
    };
    let only = std::env::var("SHOT_ONLY").ok();
    let dark = std::env::var("SHOT_DARK").is_ok();
    let loaded = data::load_once(&source).unwrap();
    let first_entry = loaded.entries.last().map(|e| e.id).unwrap_or(1);
    let first_cash = loaded.cash_accounts.first().copied().unwrap_or(1);
    let last_doc = loaded.attachments.last().map(|a| a.id).unwrap_or(1);
    let last_event = loaded.seq();
    let first_asset = loaded
        .ledger
        .registered_assets()
        .next()
        .map(|a| a.id)
        .unwrap_or(1);
    // A party with the most to show: W-9 facts first, else any.
    let party = std::env::var("SHOT_PARTY")
        .ok()
        .and_then(|p| p.parse().ok())
        .or_else(|| {
            loaded
                .ledger
                .parties()
                .find(|p| p.w9.is_some() && p.vendor.is_some())
                .or_else(|| loaded.ledger.parties().next())
                .map(|p| p.id)
        })
        .unwrap_or(1);
    let reconciliation = loaded.reconciliations.last().map(|r| r.id).unwrap_or(1);
    let voided = loaded
        .reconciliations
        .iter()
        .find(|r| r.voided.is_some())
        .map_or(reconciliation, |r| r.id);
    // A document linked to more than one subject, else the last.
    let linked_doc = loaded
        .attachments
        .iter()
        .rev()
        .find(|a| loaded.links_of(a.id).len() > 1)
        .map_or(last_doc, |a| a.id);
    // A project by name (SHOT_PROJECT: an id): the on-spec one, and the
    // client work, else the first.
    let project_named = |name: &str| {
        loaded
            .ledger
            .list_classes()
            .into_iter()
            .find(|c| c.name == name)
            .or_else(|| loaded.ledger.list_classes().into_iter().next())
            .map_or(1, |c| c.id)
    };
    let project = std::env::var("SHOT_PROJECT")
        .ok()
        .and_then(|p| p.parse().ok())
        .unwrap_or_else(|| project_named("Tidepool app"));
    let project_client = project_named("Client work");
    let project_templates = project_named("Templates");
    // An invoice whose lines name a project (else the first), and the
    // first bill: their entries' pages show the document's lines.
    let invoices = loaded.ledger.invoices();
    let invoice = invoices
        .iter()
        .find(|i| i.lines.iter().any(|l| l.class_id.is_some()))
        .or(invoices.first())
        .map(|i| i.entry_id);
    let bill = loaded.ledger.bills().first().map(|b| b.entry_id);
    drop(loaded);
    let mut routes: Vec<(&str, Route)> = vec![
        ("overview", Route::Overview),
        ("transactions", Route::Transactions),
        (
            "entry",
            Route::Entry(
                std::env::var("SHOT_ENTRY")
                    .ok()
                    .and_then(|e| e.parse().ok())
                    .unwrap_or(first_entry),
            ),
        ),
        ("cash", Route::Cash),
        ("profit", Route::Profit),
        ("pnl", Route::Reports(ReportKind::ProfitAndLoss)),
        ("balance", Route::Reports(ReportKind::BalanceSheet)),
        ("cashflow", Route::Reports(ReportKind::CashFlow)),
        ("trial", Route::Reports(ReportKind::TrialBalance)),
        ("gl", Route::Reports(ReportKind::GeneralLedger)),
        ("tax", Route::Reports(ReportKind::TaxSummary)),
        ("v1099", Route::Reports(ReportKind::Vendor1099)),
        ("ar", Route::Reports(ReportKind::ArAging)),
        (
            "asset-register",
            Route::Reports(ReportKind::FixedAssetRegister),
        ),
        ("accounts", Route::Accounts),
        ("account", Route::Account(first_cash)),
        ("assets", Route::Assets),
        ("asset", Route::Asset(first_asset)),
        ("parties", Route::Parties),
        ("party", Route::Party(party)),
        ("projects", Route::Projects),
        ("project", Route::Project(project)),
        ("project-client", Route::Project(project_client)),
        ("project-templates", Route::Project(project_templates)),
        ("document", Route::Document(last_doc)),
        ("document-linked", Route::Document(linked_doc)),
        ("reconciliation", Route::Reconciliation(reconciliation)),
        ("reconciliation-voided", Route::Reconciliation(voided)),
        ("event", Route::JournalEvent(last_event)),
        ("documents", Route::Documents),
        ("company", Route::Company),
        ("journal", Route::Journal),
    ];
    routes.extend(invoice.map(|e| ("invoice", Route::Entry(e))));
    routes.extend(bill.map(|e| ("bill", Route::Entry(e))));
    for (name, route) in routes {
        if only
            .as_deref()
            .is_some_and(|o| !o.split(',').any(|x| x == name))
        {
            continue;
        }
        let books = data::load_once(&source).unwrap();
        let mut harness = Harness::builder()
            .with_size(egui::vec2(
                std::env::var("SHOT_WIDTH")
                    .ok()
                    .and_then(|w| w.parse().ok())
                    .unwrap_or(1440.0),
                std::env::var("SHOT_HEIGHT")
                    .ok()
                    .and_then(|h| h.parse().ok())
                    .unwrap_or(920.0),
            ))
            .build_eframe(|cc| App::with_books(&cc.egui_ctx, books, dark, route.clone()));
        if std::env::var("SHOT_LIVE").is_ok() {
            harness.state_mut().show_live_label();
        }
        // SHOT_REGISTER=all: a register showing every date (after "Show
        // all dates"); otherwise it opens on the default period.
        if std::env::var("SHOT_REGISTER").is_ok_and(|r| r == "all") {
            harness.state_mut().state_mut().accounts.range =
                ledger_gui::pages::accounts::RegisterRange::All;
        }
        harness.run_steps(4);
        let ctx = harness.ctx.clone();
        harness.state_mut().settle(&ctx);
        harness.run_steps(4);
        let img = harness.render().unwrap();
        img.save(out.join(format!("{name}.png"))).unwrap();
    }
}