dugix 1.0.0

A local-first terminal chat app for deep research and multi-agent work
use super::*;
use ratatui::{Terminal, backend::TestBackend};
use serde_json::json;

fn source(days: i32) -> String {
    json!({
        "version":1,"title":"Planner","state":{"days":days,"ready":false},
        "view":[
            {"type":"toggle","key":"ready","label":"Ready"},
            {"type":"stepper","key":"days","label":"Days","min":1,"max":7,"step":2},
            {"type":"buttons","items":[{"label":"Save","action":"save"}]}
        ],"actions":{"save":[]}
    })
    .to_string()
}

fn entry(source: &str) -> Entry {
    Entry {
        focus: 1,
        ..Entry::new(Ok(Session::new(Document::parse(source).unwrap()).unwrap()))
    }
}

fn row(buffer: &Buffer, y: u16) -> String {
    (0..buffer.area.width)
        .map(|x| buffer[(x, y)].symbol())
        .collect()
}

#[test]
fn stepper_renders_one_row_at_80_columns_with_dim_label_and_bound_arrows() {
    let theme = Theme::default();
    for (days, expected, minus, plus) in [
        (5, "5", theme.fg_dim, theme.fg_dim),
        (1, "1", theme.border_dim, theme.fg_dim),
        (7, "7", theme.fg_dim, theme.border_dim),
    ] {
        let entry = entry(&source(days));
        let (buffer, hits) = entry.canvas(80, &theme, false, true);
        assert!(row(&buffer, 4).contains(&format!("Days   − {expected} +")));
        assert_eq!(buffer[(2, 4)].fg, theme.fg_dim);
        assert_eq!(buffer[(9, 4)].fg, minus);
        assert_eq!(buffer[(13, 4)].fg, plus);
        assert_eq!(buffer[(11, 4)].bg, theme.control);
        assert!(buffer[(11, 4)].modifier.contains(Modifier::BOLD));
        assert_eq!(hits[1], (Rect::new(2, 4, 76, 1), 1));
    }
    let entry = entry(&source(1));
    let (buffer, _) = entry.canvas(80, &theme, true, true);
    assert_eq!(buffer[(9, 4)].fg, theme.border_dim);
    assert_eq!(buffer[(13, 4)].fg, theme.accent);
    assert_eq!(buffer[(11, 4)].bg, theme.selection);
    assert!(!buffer[(11, 4)].modifier.contains(Modifier::UNDERLINED));
    assert_eq!(buffer[(2, 4)].fg, theme.accent);
    assert!(buffer[(2, 4)].modifier.contains(Modifier::BOLD));
    assert_eq!(buffer[(0, 4)].symbol(), "▸");
}

fn placement() -> Placement {
    let source = source(5);
    Placement {
        row: 0,
        width: 80,
        owner: 0,
        ordinal: 0,
        height: source_height(&source, 80),
        source,
        complete: true,
    }
}

fn draw(widgets: &mut Widgets, placement: &Placement) {
    let mut terminal = Terminal::new(TestBackend::new(82, 32)).unwrap();
    terminal
        .draw(|frame| {
            widgets.begin_frame(false);
            widgets.paint(
                frame,
                frame.area(),
                0,
                std::slice::from_ref(placement),
                &Theme::default(),
                true,
            );
        })
        .unwrap();
}

fn days(widgets: &Widgets, placement: &Placement) -> String {
    widgets.entries[&placement.key()]
        .session
        .as_ref()
        .unwrap()
        .value("days")
}

#[test]
fn tab_focus_and_left_right_keys_adjust_locally_without_wrapping_or_messages() {
    let p = placement();
    let mut widgets = Widgets::default();
    draw(&mut widgets, &p);
    assert!(widgets.focus_latest());
    assert!(matches!(
        &widgets.entries[&p.key()].controls()[..],
        [Control::Toggle(_), Control::Stepper(1), Control::Action(_)]
    ));
    widgets.key(KeyCode::Tab.into(), false);
    assert_eq!(widgets.entries[&p.key()].focus, 1);
    for (code, expected) in [
        (KeyCode::Right, "7"),
        (KeyCode::Right, "7"),
        (KeyCode::Left, "5"),
        (KeyCode::Left, "3"),
        (KeyCode::Left, "1"),
        (KeyCode::Left, "1"),
        (KeyCode::Enter, "1"),
        (KeyCode::Char(' '), "1"),
    ] {
        assert_eq!(widgets.key(code.into(), false), (false, None));
        assert_eq!(days(&widgets, &p), expected);
        assert_eq!(widgets.entries[&p.key()].focus, 1);
    }
    for expected in [2, 3, 0] {
        widgets.key(KeyCode::Tab.into(), false);
        assert_eq!(widgets.entries[&p.key()].focus, expected);
    }
}

fn click(widgets: &mut Widgets, offset: u16, screen: Rect) {
    let hit = widgets
        .hits
        .iter()
        .find(|hit| hit.control == Some(1))
        .unwrap();
    let event = MouseEvent {
        kind: MouseEventKind::Down(MouseButton::Left),
        column: hit.rect.x + offset,
        row: hit.rect.y,
        modifiers: KeyModifiers::NONE,
    };
    assert_eq!(widgets.click(event, screen, false), (true, None));
}

#[test]
fn clicks_only_adjust_on_arrows_inline_and_in_the_expanded_view() {
    let p = placement();
    let mut widgets = Widgets::default();
    draw(&mut widgets, &p);
    let screen = Rect::new(0, 0, 82, 32);
    for (offset, expected) in [(0, "5"), (9, "5"), (11, "7"), (12, "7"), (6, "5")] {
        click(&mut widgets, offset, screen);
        assert_eq!(days(&widgets, &p), expected);
        assert_eq!(widgets.entries[&p.key()].focus, 1);
        draw(&mut widgets, &p);
    }
    let mut terminal = Terminal::new(TestBackend::new(90, 32)).unwrap();
    terminal
        .draw(|frame| {
            widgets.popup(frame, &Theme::default(), Rect::new(3, 4, 80, 20), false);
        })
        .unwrap();
    click(&mut widgets, 6, Rect::new(0, 0, 90, 32));
    assert_eq!(days(&widgets, &p), "3");
}

#[test]
fn reserved_height_matches_drawing_even_for_narrow_steppers() {
    let source = source(5);
    let entry = entry(&source);
    for width in [0, 1, 2, 4, 8, 12, 40, 80] {
        let (buffer, _) = entry.canvas(width, &Theme::default(), false, true);
        assert_eq!(source_height(&source, width), buffer.area.height);
        let regions = node_regions(entry.session.as_ref().unwrap(), width);
        assert_eq!(regions[1].height, 1);
        assert_eq!(regions[1].bottom() + 4, buffer.area.height);
    }
}

#[test]
fn prompt_app_has_an_80_column_render_and_state_driven_progress() {
    let source = dugix_core::interactive::INSTRUCTIONS
        .split("```dugix-ui\n")
        .nth(1)
        .unwrap()
        .split("\n```")
        .next()
        .unwrap();
    let mut entry = entry(source);
    let (buffer, _) = entry.canvas(80, &Theme::default(), false, true);
    let card_row = |content: &str| format!("  {content:<78}");
    let expected = [
        format!("  {:<75}⤢  ", "Trip planner"),
        card_row(""),
        card_row(&format!("{:<14} − 5 +", "Days")),
        card_row(""),
        card_row(" ✓  Beach (2 days)"),
        card_row("    Hiking (3 days)"),
        card_row(""),
        card_row(&format!(
            "{:<14}{}{}  2 / 5",
            "Planned days",
            "━".repeat(22),
            "─".repeat(33)
        )),
        card_row(""),
        card_row("  Save plan ↵"),
        card_row(""),
        format!("{} F2 keyboard ──", "─".repeat(65)),
    ];
    assert_eq!(buffer.area.height, 12);
    let actual: Vec<_> = (0..buffer.area.height).map(|y| row(&buffer, y)).collect();
    assert_eq!(actual.join("\n"), expected.join("\n"));
    assert_eq!(source_height(source, 80), buffer.area.height);
    let session = entry.session.as_mut().unwrap();
    session.toggle("hiking").unwrap();
    session.step(0, true).unwrap();
    let (updated, _) = entry.canvas(80, &Theme::default(), false, true);
    assert!(row(&updated, 2).contains("− 6 +"));
    assert!(row(&updated, 7).contains("5 / 6"));
}